2019-07-10 15:03:37 +03:00
|
|
|
/* 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/. */
|
|
|
|
|
2022-07-26 05:46:30 +03:00
|
|
|
/* eslint-env mozilla/remote-page */
|
2022-10-07 21:40:27 +03:00
|
|
|
/* eslint-disable import/no-unassigned-import */
|
2019-05-04 02:30:35 +03:00
|
|
|
|
2022-06-10 22:21:05 +03:00
|
|
|
import "chrome://global/content/certviewer/pvutils_bundle.jsm";
|
|
|
|
import "chrome://global/content/certviewer/asn1js_bundle.jsm";
|
|
|
|
import "chrome://global/content/certviewer/pkijs_bundle.jsm";
|
|
|
|
import "chrome://global/content/certviewer/certDecoder.jsm";
|
2021-04-21 20:48:21 +03:00
|
|
|
|
|
|
|
const { Integer, fromBER } = globalThis.asn1js.asn1js;
|
|
|
|
const { Certificate } = globalThis.pkijs.pkijs;
|
|
|
|
const { fromBase64, stringToArrayBuffer } = globalThis.pvutils.pvutils;
|
|
|
|
const { parse, pemToDER } = globalThis.certDecoderInitializer(
|
|
|
|
Integer,
|
|
|
|
fromBER,
|
|
|
|
Certificate,
|
|
|
|
fromBase64,
|
|
|
|
stringToArrayBuffer,
|
|
|
|
crypto
|
|
|
|
);
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const formatter = new Intl.DateTimeFormat();
|
2019-10-28 23:38:45 +03:00
|
|
|
|
2022-12-02 00:40:57 +03:00
|
|
|
const HOST_NAME =
|
|
|
|
new URL(RPMGetInnerMostURI(document.location.href)).hostname ?? "";
|
2020-10-27 13:55:51 +03:00
|
|
|
|
2020-07-06 14:12:08 +03:00
|
|
|
// Used to check if we have a specific localized message for an error.
|
|
|
|
const KNOWN_ERROR_TITLE_IDS = new Set([
|
|
|
|
// Error titles:
|
|
|
|
"connectionFailure-title",
|
|
|
|
"deniedPortAccess-title",
|
|
|
|
"dnsNotFound-title",
|
|
|
|
"fileNotFound-title",
|
|
|
|
"fileAccessDenied-title",
|
|
|
|
"generic-title",
|
|
|
|
"captivePortal-title",
|
|
|
|
"malformedURI-title",
|
|
|
|
"netInterrupt-title",
|
|
|
|
"notCached-title",
|
|
|
|
"netOffline-title",
|
|
|
|
"contentEncodingError-title",
|
|
|
|
"unsafeContentType-title",
|
|
|
|
"netReset-title",
|
|
|
|
"netTimeout-title",
|
|
|
|
"unknownProtocolFound-title",
|
|
|
|
"proxyConnectFailure-title",
|
|
|
|
"proxyResolveFailure-title",
|
|
|
|
"redirectLoop-title",
|
|
|
|
"unknownSocketType-title",
|
|
|
|
"nssFailure2-title",
|
|
|
|
"csp-xfo-error-title",
|
|
|
|
"corruptedContentError-title",
|
|
|
|
"sslv3Used-title",
|
|
|
|
"inadequateSecurityError-title",
|
|
|
|
"blockedByPolicy-title",
|
|
|
|
"clockSkewError-title",
|
|
|
|
"networkProtocolError-title",
|
|
|
|
"nssBadCert-title",
|
|
|
|
"nssBadCert-sts-title",
|
|
|
|
"certerror-mitm-title",
|
|
|
|
]);
|
|
|
|
|
|
|
|
/* The error message IDs from nsserror.ftl get processed into
|
|
|
|
* aboutNetErrorCodes.js which is loaded before we are: */
|
|
|
|
/* global KNOWN_ERROR_MESSAGE_IDS */
|
2022-10-12 15:34:36 +03:00
|
|
|
const ERROR_MESSAGES_FTL = "toolkit/neterror/nsserrors.ftl";
|
2020-07-06 14:12:08 +03:00
|
|
|
|
2018-04-26 11:07:07 +03:00
|
|
|
// The following parameters are parsed from the error URL:
|
|
|
|
// e - the error code
|
|
|
|
// s - custom CSS class to allow alternate styling/favicons
|
|
|
|
// d - error description
|
|
|
|
// captive - "true" to indicate we're behind a captive portal.
|
|
|
|
// Any other value is ignored.
|
|
|
|
|
|
|
|
// Note that this file uses document.documentURI to get
|
|
|
|
// the URL (with the format from above). This is because
|
|
|
|
// document.location.href gets the current URI off the docshell,
|
|
|
|
// which is the URL displayed in the location bar, i.e.
|
|
|
|
// the URI that the user attempted to load.
|
|
|
|
|
|
|
|
let searchParams = new URLSearchParams(document.documentURI.split("?")[1]);
|
|
|
|
|
2021-07-29 18:39:56 +03:00
|
|
|
let gErrorCode = searchParams.get("e");
|
|
|
|
let gIsCertError = gErrorCode == "nssBadCert";
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
let gHasSts = gIsCertError && getCSSClass() === "badStsCert";
|
2021-07-29 18:39:56 +03:00
|
|
|
|
|
|
|
// If the location of the favicon changes, FAVICON_CERTERRORPAGE_URL and/or
|
|
|
|
// FAVICON_ERRORPAGE_URL in toolkit/components/places/nsFaviconService.idl
|
|
|
|
// should also be updated.
|
|
|
|
document.getElementById("favicon").href =
|
|
|
|
gIsCertError || gErrorCode == "nssFailure2"
|
|
|
|
? "chrome://global/skin/icons/warning.svg"
|
|
|
|
: "chrome://global/skin/icons/info.svg";
|
2018-04-26 11:07:07 +03:00
|
|
|
|
|
|
|
function getCSSClass() {
|
|
|
|
return searchParams.get("s");
|
|
|
|
}
|
|
|
|
|
|
|
|
function getDescription() {
|
|
|
|
return searchParams.get("d");
|
|
|
|
}
|
|
|
|
|
|
|
|
function isCaptive() {
|
|
|
|
return searchParams.get("captive") == "true";
|
|
|
|
}
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
/**
|
|
|
|
* We don't actually know what the MitM is called (since we don't
|
|
|
|
* maintain a list), so we'll try and display the common name of the
|
|
|
|
* root issuer to the user. In the worst case they are as clueless as
|
|
|
|
* before, in the best case this gives them an actionable hint.
|
|
|
|
* This may be revised in the future.
|
|
|
|
*/
|
|
|
|
function getMitmName(failedCertInfo) {
|
|
|
|
return failedCertInfo.issuerCommonName;
|
|
|
|
}
|
|
|
|
|
2018-04-26 11:07:07 +03:00
|
|
|
function retryThis(buttonEl) {
|
2019-09-05 23:04:03 +03:00
|
|
|
RPMSendAsyncMessage("Browser:EnableOnlineMode");
|
2018-04-26 11:07:07 +03:00
|
|
|
buttonEl.disabled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
function showPrefChangeContainer() {
|
|
|
|
const panel = document.getElementById("prefChangeContainer");
|
2022-10-07 21:40:29 +03:00
|
|
|
panel.hidden = false;
|
|
|
|
document.getElementById("netErrorButtonContainer").hidden = true;
|
2018-04-26 11:07:07 +03:00
|
|
|
document
|
|
|
|
.getElementById("prefResetButton")
|
2019-10-28 23:39:01 +03:00
|
|
|
.addEventListener("click", function resetPreferences() {
|
|
|
|
RPMSendAsyncMessage("Browser:ResetSSLPreferences");
|
2018-04-26 11:07:07 +03:00
|
|
|
});
|
2021-05-21 21:13:29 +03:00
|
|
|
setFocus("#prefResetButton", "beforeend");
|
2018-04-26 11:07:07 +03:00
|
|
|
}
|
|
|
|
|
2021-09-01 20:19:21 +03:00
|
|
|
function toggleCertErrorDebugInfoVisibility(shouldShow) {
|
|
|
|
let debugInfo = document.getElementById("certificateErrorDebugInformation");
|
|
|
|
let copyButton = document.getElementById("copyToClipboardTop");
|
|
|
|
|
|
|
|
if (shouldShow === undefined) {
|
|
|
|
shouldShow = debugInfo.hidden;
|
|
|
|
}
|
2021-12-01 17:59:42 +03:00
|
|
|
debugInfo.hidden = !shouldShow;
|
2021-09-01 20:19:21 +03:00
|
|
|
if (shouldShow) {
|
|
|
|
copyButton.scrollIntoView({ block: "start", behavior: "smooth" });
|
|
|
|
copyButton.focus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-26 11:07:07 +03:00
|
|
|
function setupAdvancedButton() {
|
|
|
|
// Get the hostname and add it to the panel
|
|
|
|
var panel = document.getElementById("badCertAdvancedPanel");
|
|
|
|
|
|
|
|
// Register click handler for the weakCryptoAdvancedPanel
|
2018-08-02 20:29:04 +03:00
|
|
|
document
|
|
|
|
.getElementById("advancedButton")
|
|
|
|
.addEventListener("click", togglePanelVisibility);
|
|
|
|
|
|
|
|
function togglePanelVisibility() {
|
2021-12-01 17:59:42 +03:00
|
|
|
panel.hidden = !panel.hidden;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
|
|
|
|
// Toggling the advanced panel must ensure that the debugging
|
|
|
|
// information panel is hidden as well, since it's opened by the
|
|
|
|
// error code link in the advanced panel.
|
|
|
|
toggleCertErrorDebugInfoVisibility(false);
|
2018-04-26 11:07:07 +03:00
|
|
|
|
2022-10-07 21:40:29 +03:00
|
|
|
if (!panel.hidden) {
|
2018-04-26 11:07:07 +03:00
|
|
|
// send event to trigger telemetry ping
|
|
|
|
var event = new CustomEvent("AboutNetErrorUIExpanded", { bubbles: true });
|
|
|
|
document.dispatchEvent(event);
|
|
|
|
}
|
2018-08-02 20:29:04 +03:00
|
|
|
}
|
2018-04-26 11:07:07 +03:00
|
|
|
|
|
|
|
if (getCSSClass() == "expertBadCert") {
|
2021-12-01 17:59:42 +03:00
|
|
|
panel.hidden = false;
|
2018-04-26 11:07:07 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function disallowCertOverridesIfNeeded() {
|
|
|
|
// Disallow overrides if this is a Strict-Transport-Security
|
|
|
|
// host and the cert is bad (STS Spec section 7.3) or if the
|
|
|
|
// certerror is in a frame (bug 633691).
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
if (gHasSts || window != top) {
|
2021-02-14 02:33:51 +03:00
|
|
|
document.getElementById("exceptionDialogButton").hidden = true;
|
2018-04-26 11:07:07 +03:00
|
|
|
}
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
if (gHasSts) {
|
|
|
|
const stsExplanation = document.getElementById("badStsCertExplanation");
|
|
|
|
document.l10n.setAttributes(
|
|
|
|
stsExplanation,
|
|
|
|
"certerror-what-should-i-do-bad-sts-cert-explanation",
|
|
|
|
{ hostname: HOST_NAME }
|
|
|
|
);
|
2022-10-07 21:40:29 +03:00
|
|
|
stsExplanation.hidden = false;
|
2020-03-26 17:35:50 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(
|
|
|
|
document.getElementById("returnButton"),
|
|
|
|
"neterror-return-to-previous-page-button"
|
|
|
|
);
|
|
|
|
document.l10n.setAttributes(
|
|
|
|
document.getElementById("advancedPanelReturnButton"),
|
|
|
|
"neterror-return-to-previous-page-button"
|
|
|
|
);
|
2020-07-06 14:12:08 +03:00
|
|
|
}
|
2020-03-26 17:35:50 +03:00
|
|
|
}
|
|
|
|
|
2018-04-26 11:07:07 +03:00
|
|
|
function initPage() {
|
2021-04-22 18:11:37 +03:00
|
|
|
// We show an offline support page in case of a system-wide error,
|
|
|
|
// when a user cannot connect to the internet and access the SUMO website.
|
|
|
|
// For example, clock error, which causes certerrors across the web or
|
|
|
|
// a security software conflict where the user is unable to connect
|
|
|
|
// to the internet.
|
|
|
|
// The URL that prompts us to show an offline support page should have the following
|
|
|
|
// format: "https://support.mozilla.org/1/firefox/%VERSION%/%OS%/%LOCALE%/supportPageSlug",
|
|
|
|
// so we can extract the support page slug.
|
|
|
|
let baseURL = RPMGetFormatURLPref("app.support.baseURL");
|
|
|
|
let location = document.location.href;
|
|
|
|
if (location.startsWith(baseURL)) {
|
|
|
|
let supportPageSlug = document.location.pathname.split("/").pop();
|
|
|
|
RPMSendAsyncMessage("DisplayOfflineSupportPage", {
|
|
|
|
supportPageSlug,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const className = getCSSClass();
|
2018-10-16 21:50:37 +03:00
|
|
|
if (className) {
|
|
|
|
document.body.classList.add(className);
|
|
|
|
}
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const docTitle = document.querySelector("title");
|
|
|
|
const bodyTitle = document.querySelector(".title-text");
|
2022-10-07 21:40:29 +03:00
|
|
|
const shortDesc = document.getElementById("errorShortDesc");
|
2020-02-20 15:59:05 +03:00
|
|
|
|
2018-04-26 11:07:07 +03:00
|
|
|
if (gIsCertError) {
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const isStsError = window !== window.top || gHasSts;
|
|
|
|
const errArgs = { hostname: HOST_NAME };
|
|
|
|
if (isCaptive()) {
|
|
|
|
document.l10n.setAttributes(
|
|
|
|
docTitle,
|
|
|
|
"neterror-captive-portal-page-title"
|
|
|
|
);
|
|
|
|
document.l10n.setAttributes(bodyTitle, "captivePortal-title");
|
|
|
|
document.l10n.setAttributes(
|
|
|
|
shortDesc,
|
|
|
|
"neterror-captive-portal",
|
|
|
|
errArgs
|
|
|
|
);
|
2020-02-20 15:59:05 +03:00
|
|
|
initPageCaptivePortal();
|
|
|
|
} else {
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
if (isStsError) {
|
|
|
|
document.l10n.setAttributes(docTitle, "certerror-sts-page-title");
|
|
|
|
document.l10n.setAttributes(bodyTitle, "nssBadCert-sts-title");
|
|
|
|
document.l10n.setAttributes(shortDesc, "certerror-sts-intro", errArgs);
|
|
|
|
} else {
|
|
|
|
document.l10n.setAttributes(docTitle, "certerror-page-title");
|
|
|
|
document.l10n.setAttributes(bodyTitle, "nssBadCert-title");
|
|
|
|
document.l10n.setAttributes(shortDesc, "certerror-intro", errArgs);
|
|
|
|
}
|
2020-02-20 15:59:05 +03:00
|
|
|
initPageCertError();
|
|
|
|
}
|
|
|
|
|
|
|
|
initCertErrorPageActions();
|
|
|
|
setTechnicalDetailsOnCertError();
|
2018-04-26 11:07:07 +03:00
|
|
|
return;
|
|
|
|
}
|
2020-02-20 15:59:05 +03:00
|
|
|
|
2018-04-26 11:07:07 +03:00
|
|
|
document.body.classList.add("neterror");
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
let longDesc = document.getElementById("errorLongDesc");
|
2022-10-07 21:40:29 +03:00
|
|
|
const tryAgain = document.getElementById("netErrorButtonContainer");
|
|
|
|
tryAgain.hidden = false;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const learnMore = document.getElementById("learnMoreContainer");
|
|
|
|
const learnMoreLink = document.getElementById("learnMoreLink");
|
|
|
|
learnMoreLink.setAttribute("href", baseURL + "connection-not-secure");
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
let pageTitleId = "neterror-page-title";
|
|
|
|
let bodyTitleId = gErrorCode + "-title";
|
2022-07-19 06:27:18 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
switch (gErrorCode) {
|
|
|
|
case "blockedByPolicy":
|
|
|
|
pageTitleId = "neterror-blocked-by-policy-page-title";
|
|
|
|
document.body.classList.add("blocked");
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// Remove the "Try again" button from pages that don't need it.
|
|
|
|
// For pages blocked by policy, trying again won't help.
|
2022-10-07 21:40:29 +03:00
|
|
|
tryAgain.hidden = true;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
break;
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
case "cspBlocked":
|
|
|
|
case "xfoBlocked": {
|
|
|
|
bodyTitleId = "csp-xfo-error-title";
|
2020-06-12 15:41:02 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// Remove the "Try again" button for XFO and CSP violations,
|
|
|
|
// since it's almost certainly useless. (Bug 553180)
|
2022-10-07 21:40:29 +03:00
|
|
|
tryAgain.hidden = true;
|
2020-05-26 13:17:50 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// Adding a button for opening websites blocked for CSP and XFO violations
|
|
|
|
// in a new window. (Bug 1461195)
|
2022-10-07 21:40:29 +03:00
|
|
|
document.getElementById("errorShortDesc").hidden = true;
|
2020-05-26 13:17:50 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(longDesc, "csp-xfo-blocked-long-desc", {
|
|
|
|
hostname: document.location.hostname, // FIXME - should this be HOST_NAME?
|
|
|
|
});
|
|
|
|
longDesc = null;
|
2020-05-26 13:17:50 +03:00
|
|
|
|
2022-10-07 21:40:29 +03:00
|
|
|
document.getElementById("openInNewWindowContainer").hidden = false;
|
2020-05-26 13:17:50 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const openInNewWindowButton = document.getElementById(
|
|
|
|
"openInNewWindowButton"
|
|
|
|
);
|
|
|
|
openInNewWindowButton.href = document.location.href;
|
2020-06-12 15:41:02 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// Add a learn more link
|
2022-10-07 21:40:29 +03:00
|
|
|
learnMore.hidden = false;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
learnMoreLink.setAttribute("href", baseURL + "xframe-neterror-page");
|
2020-07-22 18:12:38 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
setupBlockingReportingUI();
|
|
|
|
break;
|
|
|
|
}
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
case "dnsNotFound":
|
|
|
|
pageTitleId = "neterror-dns-not-found-title";
|
|
|
|
RPMCheckAlternateHostAvailable();
|
|
|
|
break;
|
2019-09-17 12:49:59 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
case "inadequateSecurityError":
|
|
|
|
// Remove the "Try again" button from pages that don't need it.
|
|
|
|
// For HTTP/2 inadequate security, trying again won't help.
|
2022-10-07 21:40:29 +03:00
|
|
|
tryAgain.hidden = true;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
case "malformedURI":
|
|
|
|
pageTitleId = "neterror-malformed-uri-page-title";
|
2022-10-07 21:40:29 +03:00
|
|
|
// Remove the "Try again" button from pages that don't need it.
|
|
|
|
tryAgain.hidden = true;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
break;
|
2019-09-17 12:49:59 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// Pinning errors are of type nssFailure2
|
|
|
|
case "nssFailure2": {
|
2022-10-07 21:40:29 +03:00
|
|
|
learnMore.hidden = false;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
|
|
|
|
const errorCode = document.getNetErrorInfo().errorCodeString;
|
|
|
|
switch (errorCode) {
|
|
|
|
case "SSL_ERROR_UNSUPPORTED_VERSION":
|
|
|
|
case "SSL_ERROR_PROTOCOL_VERSION_ALERT": {
|
|
|
|
const tlsNotice = document.getElementById("tlsVersionNotice");
|
|
|
|
tlsNotice.hidden = false;
|
|
|
|
document.l10n.setAttributes(tlsNotice, "cert-error-old-tls-version");
|
|
|
|
}
|
|
|
|
// fallthrough
|
|
|
|
|
|
|
|
case "interrupted": // This happens with subresources that are above the max tls
|
|
|
|
case "SSL_ERROR_NO_CIPHERS_SUPPORTED":
|
|
|
|
case "SSL_ERROR_NO_CYPHER_OVERLAP":
|
|
|
|
case "SSL_ERROR_SSL_DISABLED":
|
|
|
|
RPMAddMessageListener("HasChangedCertPrefs", msg => {
|
|
|
|
if (msg.data.hasChangedCertPrefs) {
|
|
|
|
// Configuration overrides might have caused this; offer to reset.
|
|
|
|
showPrefChangeContainer();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
RPMSendAsyncMessage("GetChangedCertPrefs");
|
|
|
|
}
|
2019-09-17 12:49:59 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
break;
|
2021-12-29 02:39:43 +03:00
|
|
|
}
|
2019-09-17 12:49:59 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
case "sslv3Used":
|
2022-10-07 21:40:29 +03:00
|
|
|
learnMore.hidden = false;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.body.className = "certerror";
|
|
|
|
break;
|
|
|
|
}
|
2021-12-29 02:39:43 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(docTitle, pageTitleId);
|
|
|
|
|
|
|
|
if (!KNOWN_ERROR_TITLE_IDS.has(bodyTitleId)) {
|
2022-10-07 21:40:29 +03:00
|
|
|
console.error("No strings exist for error:", gErrorCode);
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
bodyTitleId = "generic-title";
|
2019-09-17 12:49:59 +03:00
|
|
|
}
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(bodyTitle, bodyTitleId);
|
|
|
|
|
|
|
|
shortDesc.textContent = getDescription();
|
|
|
|
|
|
|
|
setFocus("#netErrorButtonContainer > .try-again");
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
if (longDesc) {
|
|
|
|
const parts = getNetErrorDescParts();
|
|
|
|
setNetErrorMessageFromParts(longDesc, parts);
|
2019-09-17 12:49:59 +03:00
|
|
|
}
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
setNetErrorMessageFromCode();
|
|
|
|
}
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
/**
|
|
|
|
* Builds HTML elements from `parts` and appends them to `parent`.
|
|
|
|
*
|
|
|
|
* @param {HTMLElement} parent
|
|
|
|
* @param {Array<["li" | "p" | "span", string, Record<string, string> | undefined]>} parts
|
|
|
|
*/
|
|
|
|
function setNetErrorMessageFromParts(parent, parts) {
|
|
|
|
let list = null;
|
|
|
|
|
|
|
|
for (let [tag, l10nId, l10nArgs] of parts) {
|
|
|
|
const elem = document.createElement(tag);
|
|
|
|
elem.dataset.l10nId = l10nId;
|
|
|
|
if (l10nArgs) {
|
|
|
|
elem.dataset.l10nArgs = JSON.stringify(l10nArgs);
|
2018-04-26 11:07:07 +03:00
|
|
|
}
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
|
|
|
|
if (tag === "li") {
|
|
|
|
if (!list) {
|
|
|
|
list = document.createElement("ul");
|
|
|
|
parent.appendChild(list);
|
|
|
|
}
|
|
|
|
list.appendChild(elem);
|
|
|
|
} else {
|
|
|
|
if (list) {
|
|
|
|
list = null;
|
|
|
|
}
|
|
|
|
parent.appendChild(elem);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns an array of tuples determining the parts of an error message:
|
|
|
|
* - HTML tag name
|
|
|
|
* - l10n id
|
|
|
|
* - l10n args (optional)
|
|
|
|
*
|
|
|
|
* @returns { Array<["li" | "p" | "span", string, Record<string, string> | undefined]> }
|
|
|
|
*/
|
|
|
|
function getNetErrorDescParts() {
|
|
|
|
switch (gErrorCode) {
|
|
|
|
case "connectionFailure":
|
|
|
|
case "netInterrupt":
|
|
|
|
case "netReset":
|
|
|
|
case "netTimeout":
|
|
|
|
return [
|
|
|
|
["li", "neterror-load-error-try-again"],
|
|
|
|
["li", "neterror-load-error-connection"],
|
|
|
|
["li", "neterror-load-error-firewall"],
|
|
|
|
];
|
|
|
|
|
|
|
|
case "blockedByPolicy":
|
|
|
|
case "deniedPortAccess":
|
|
|
|
case "malformedURI":
|
|
|
|
return [];
|
|
|
|
|
|
|
|
case "captivePortal":
|
|
|
|
return [["p", ""]];
|
|
|
|
case "contentEncodingError":
|
|
|
|
return [["li", "neterror-content-encoding-error"]];
|
|
|
|
case "corruptedContentErrorv2":
|
|
|
|
return [
|
|
|
|
["p", "neterror-corrupted-content-intro"],
|
|
|
|
["li", "neterror-corrupted-content-contact-website"],
|
|
|
|
];
|
|
|
|
case "dnsNotFound":
|
|
|
|
return [
|
|
|
|
["span", "neterror-dns-not-found-hint-header"],
|
|
|
|
["li", "neterror-dns-not-found-hint-try-again"],
|
|
|
|
["li", "neterror-dns-not-found-hint-check-network"],
|
|
|
|
["li", "neterror-dns-not-found-hint-firewall"],
|
|
|
|
];
|
|
|
|
case "fileAccessDenied":
|
|
|
|
return [["li", "neterror-access-denied"]];
|
|
|
|
case "fileNotFound":
|
|
|
|
return [
|
|
|
|
["li", "neterror-file-not-found-filename"],
|
|
|
|
["li", "neterror-file-not-found-moved"],
|
|
|
|
];
|
|
|
|
case "inadequateSecurityError":
|
|
|
|
return [
|
|
|
|
["p", "neterror-inadequate-security-intro", { hostname: HOST_NAME }],
|
|
|
|
["p", "neterror-inadequate-security-code"],
|
|
|
|
];
|
|
|
|
case "mitm": {
|
|
|
|
const failedCertInfo = document.getFailedCertSecurityInfo();
|
|
|
|
const errArgs = {
|
|
|
|
hostname: HOST_NAME,
|
|
|
|
mitm: getMitmName(failedCertInfo),
|
|
|
|
};
|
|
|
|
return [["span", "certerror-mitm", errArgs]];
|
|
|
|
}
|
|
|
|
case "netOffline":
|
|
|
|
return [["li", "neterror-net-offline"]];
|
|
|
|
case "networkProtocolError":
|
|
|
|
return [
|
|
|
|
["p", "neterror-network-protocol-error-intro"],
|
|
|
|
["li", "neterror-network-protocol-error-contact-website"],
|
|
|
|
];
|
|
|
|
case "notCached":
|
|
|
|
return [
|
|
|
|
["p", "neterror-not-cached-intro"],
|
|
|
|
["li", "neterror-not-cached-sensitive"],
|
|
|
|
["li", "neterror-not-cached-try-again"],
|
|
|
|
];
|
|
|
|
case "nssFailure2":
|
|
|
|
return [
|
|
|
|
["li", "neterror-nss-failure-not-verified"],
|
|
|
|
["li", "neterror-nss-failure-contact-website"],
|
|
|
|
];
|
|
|
|
case "proxyConnectFailure":
|
|
|
|
return [
|
|
|
|
["li", "neterror-proxy-connect-failure-settings"],
|
|
|
|
["li", "neterror-proxy-connect-failure-contact-admin"],
|
|
|
|
];
|
|
|
|
case "proxyResolveFailure":
|
|
|
|
return [
|
|
|
|
["li", "neterror-proxy-resolve-failure-settings"],
|
|
|
|
["li", "neterror-proxy-resolve-failure-connection"],
|
|
|
|
["li", "neterror-proxy-resolve-failure-firewall"],
|
|
|
|
];
|
|
|
|
case "redirectLoop":
|
|
|
|
return [["li", "neterror-redirect-loop"]];
|
|
|
|
case "sslv3Used":
|
|
|
|
return [["span", "neterror-sslv3-used"]];
|
|
|
|
case "unknownProtocolFound":
|
|
|
|
return [["li", "neterror-unknown-protocol"]];
|
|
|
|
case "unknownSocketType":
|
|
|
|
return [
|
|
|
|
["li", "neterror-unknown-socket-type-psm-installed"],
|
|
|
|
["li", "neterror-unknown-socket-type-server-config"],
|
|
|
|
];
|
|
|
|
case "unsafeContentType":
|
|
|
|
return [["li", "neterror-unsafe-content-type"]];
|
|
|
|
|
|
|
|
default:
|
|
|
|
return [["p", "neterror-generic-error"]];
|
2018-04-26 11:07:07 +03:00
|
|
|
}
|
2018-06-18 20:34:56 +03:00
|
|
|
}
|
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
function setNetErrorMessageFromCode() {
|
|
|
|
let errorCode;
|
|
|
|
try {
|
|
|
|
errorCode = document.getNetErrorInfo().errorCodeString;
|
|
|
|
} catch (ex) {
|
|
|
|
// We don't have a securityInfo when this is for example a DNS error.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let errorMessage;
|
|
|
|
if (errorCode) {
|
|
|
|
const l10nId = errorCode.replace(/_/g, "-").toLowerCase();
|
|
|
|
if (KNOWN_ERROR_MESSAGE_IDS.has(l10nId)) {
|
|
|
|
const l10n = new Localization([ERROR_MESSAGES_FTL], true);
|
|
|
|
errorMessage = l10n.formatValueSync(l10nId);
|
|
|
|
}
|
|
|
|
|
|
|
|
const shortDesc2 = document.getElementById("errorShortDesc2");
|
|
|
|
document.l10n.setAttributes(shortDesc2, "cert-error-code-prefix", {
|
|
|
|
error: errorCode,
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
console.warn("This error page has no error code in its security info");
|
|
|
|
}
|
|
|
|
|
|
|
|
let hostname = HOST_NAME;
|
|
|
|
const { port } = document.location;
|
|
|
|
if (port && port != 443) {
|
|
|
|
hostname += ":" + port;
|
|
|
|
}
|
|
|
|
|
|
|
|
const shortDesc = document.getElementById("errorShortDesc");
|
|
|
|
document.l10n.setAttributes(shortDesc, "cert-error-ssl-connection-error", {
|
|
|
|
errorMessage: errorMessage ?? errorCode ?? "",
|
|
|
|
hostname,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-07-22 18:12:38 +03:00
|
|
|
function setupBlockingReportingUI() {
|
|
|
|
let checkbox = document.getElementById("automaticallyReportBlockingInFuture");
|
|
|
|
|
|
|
|
let reportingAutomatic = RPMGetBoolPref(
|
|
|
|
"security.xfocsp.errorReporting.automatic"
|
|
|
|
);
|
|
|
|
checkbox.checked = !!reportingAutomatic;
|
|
|
|
|
|
|
|
checkbox.addEventListener("change", function({ target: { checked } }) {
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
RPMSetBoolPref("security.xfocsp.errorReporting.automatic", checked);
|
|
|
|
|
|
|
|
// If we're enabling reports, send a report for this failure.
|
|
|
|
if (checked) {
|
|
|
|
reportBlockingError();
|
|
|
|
}
|
2020-07-22 18:12:38 +03:00
|
|
|
});
|
|
|
|
|
|
|
|
let reportingEnabled = RPMGetBoolPref(
|
|
|
|
"security.xfocsp.errorReporting.enabled"
|
|
|
|
);
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
if (reportingEnabled) {
|
|
|
|
// Display blocking error reporting UI for XFO error and CSP error.
|
|
|
|
document.getElementById("blockingErrorReporting").hidden = false;
|
2020-07-22 18:12:38 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
if (reportingAutomatic) {
|
|
|
|
reportBlockingError();
|
|
|
|
}
|
2020-07-22 18:12:38 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function reportBlockingError() {
|
|
|
|
// We only report if we are in a frame.
|
|
|
|
if (window === window.top) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-07-29 18:39:56 +03:00
|
|
|
let err = gErrorCode;
|
2020-07-22 18:12:38 +03:00
|
|
|
// Ensure we only deal with XFO and CSP here.
|
|
|
|
if (!["xfoBlocked", "cspBlocked"].includes(err)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let xfo_header = RPMGetHttpResponseHeader("X-Frame-Options");
|
|
|
|
let csp_header = RPMGetHttpResponseHeader("Content-Security-Policy");
|
|
|
|
|
|
|
|
// Extract the 'CSP: frame-ancestors' from the CSP header.
|
|
|
|
let reg = /(?:^|\s)frame-ancestors\s([^;]*)[$]*/i;
|
|
|
|
let match = reg.exec(csp_header);
|
|
|
|
csp_header = match ? match[1] : "";
|
|
|
|
|
|
|
|
// If it's the csp error page without the CSP: frame-ancestors, this means
|
|
|
|
// this error page is not triggered by CSP: frame-ancestors. So, we bail out
|
|
|
|
// early.
|
|
|
|
if (err === "cspBlocked" && !csp_header) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let xfoAndCspInfo = {
|
|
|
|
error_type: err === "xfoBlocked" ? "xfo" : "csp",
|
|
|
|
xfo_header,
|
|
|
|
csp_header,
|
|
|
|
};
|
|
|
|
|
2021-08-09 12:38:26 +03:00
|
|
|
// Trimming the tail colon symbol.
|
|
|
|
let scheme = document.location.protocol.slice(0, -1);
|
|
|
|
|
2020-07-22 18:12:38 +03:00
|
|
|
RPMSendAsyncMessage("ReportBlockingError", {
|
2021-08-09 12:38:26 +03:00
|
|
|
scheme,
|
2020-07-22 18:12:38 +03:00
|
|
|
host: document.location.host,
|
|
|
|
port: parseInt(document.location.port) || -1,
|
|
|
|
path: document.location.pathname,
|
|
|
|
xfoAndCspInfo,
|
|
|
|
});
|
2020-07-22 18:12:38 +03:00
|
|
|
}
|
|
|
|
|
2018-04-26 11:07:07 +03:00
|
|
|
function initPageCaptivePortal() {
|
|
|
|
document.body.className = "captiveportal";
|
2022-10-07 21:40:29 +03:00
|
|
|
document.getElementById("returnButton").hidden = true;
|
|
|
|
const openButton = document.getElementById("openPortalLoginPageButton");
|
|
|
|
openButton.hidden = false;
|
|
|
|
openButton.addEventListener("click", () => {
|
|
|
|
RPMSendAsyncMessage("Browser:OpenCaptivePortalPage");
|
|
|
|
});
|
2018-04-26 11:07:07 +03:00
|
|
|
|
2021-05-21 21:13:29 +03:00
|
|
|
setFocus("#openPortalLoginPageButton");
|
2018-04-26 11:07:07 +03:00
|
|
|
setupAdvancedButton();
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
disallowCertOverridesIfNeeded();
|
2018-04-26 11:07:07 +03:00
|
|
|
|
2019-05-04 02:30:35 +03:00
|
|
|
// When the portal is freed, an event is sent by the parent process
|
2018-04-26 11:07:07 +03:00
|
|
|
// that we can pick up and attempt to reload the original page.
|
2019-05-04 02:30:35 +03:00
|
|
|
RPMAddMessageListener("AboutNetErrorCaptivePortalFreed", () => {
|
2018-04-26 11:07:07 +03:00
|
|
|
document.location.reload();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function initPageCertError() {
|
2018-10-16 21:50:37 +03:00
|
|
|
document.body.classList.add("certerror");
|
2018-04-26 11:07:07 +03:00
|
|
|
|
2021-05-21 21:13:29 +03:00
|
|
|
setFocus("#returnButton");
|
2018-04-26 11:07:07 +03:00
|
|
|
setupAdvancedButton();
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
disallowCertOverridesIfNeeded();
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const hideAddExceptionButton = RPMGetBoolPref(
|
2019-07-25 01:07:12 +03:00
|
|
|
"security.certerror.hideAddException",
|
|
|
|
false
|
2019-06-26 23:24:05 +03:00
|
|
|
);
|
|
|
|
if (hideAddExceptionButton) {
|
2022-10-07 21:40:29 +03:00
|
|
|
document.getElementById("exceptionDialogButton").hidden = true;
|
2019-06-26 23:24:05 +03:00
|
|
|
}
|
2018-04-26 11:07:07 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const els = document.querySelectorAll("[data-telemetry-id]");
|
2020-04-25 21:12:32 +03:00
|
|
|
for (let el of els) {
|
|
|
|
el.addEventListener("click", recordClickTelemetry);
|
|
|
|
}
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const failedCertInfo = document.getFailedCertSecurityInfo();
|
2020-04-25 21:12:32 +03:00
|
|
|
// Truncate the error code to avoid going over the allowed
|
|
|
|
// string size limit for telemetry events.
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const errorCode = failedCertInfo.errorCodeString.substring(0, 40);
|
2020-04-25 21:12:32 +03:00
|
|
|
RPMRecordTelemetryEvent(
|
|
|
|
"security.ui.certerror",
|
|
|
|
"load",
|
|
|
|
"aboutcerterror",
|
|
|
|
errorCode,
|
|
|
|
{
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
has_sts: gHasSts.toString(),
|
2020-04-25 21:12:32 +03:00
|
|
|
is_frame: (window.parent != window).toString(),
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
2020-02-20 15:59:05 +03:00
|
|
|
setCertErrorDetails();
|
|
|
|
}
|
|
|
|
|
2020-04-25 21:12:32 +03:00
|
|
|
function recordClickTelemetry(e) {
|
|
|
|
let target = e.originalTarget;
|
|
|
|
let telemetryId = target.dataset.telemetryId;
|
|
|
|
let failedCertInfo = document.getFailedCertSecurityInfo();
|
|
|
|
// Truncate the error code to avoid going over the allowed
|
|
|
|
// string size limit for telemetry events.
|
|
|
|
let errorCode = failedCertInfo.errorCodeString.substring(0, 40);
|
|
|
|
RPMRecordTelemetryEvent(
|
|
|
|
"security.ui.certerror",
|
|
|
|
"click",
|
|
|
|
telemetryId,
|
|
|
|
errorCode,
|
|
|
|
{
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
has_sts: gHasSts.toString(),
|
2020-04-25 21:12:32 +03:00
|
|
|
is_frame: (window.parent != window).toString(),
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-02-20 15:59:05 +03:00
|
|
|
function initCertErrorPageActions() {
|
2022-10-07 21:40:29 +03:00
|
|
|
document.getElementById(
|
|
|
|
"certErrorAndCaptivePortalButtonContainer"
|
|
|
|
).hidden = false;
|
2019-09-05 23:04:03 +03:00
|
|
|
document
|
|
|
|
.getElementById("returnButton")
|
|
|
|
.addEventListener("click", onReturnButtonClick);
|
|
|
|
document
|
|
|
|
.getElementById("advancedPanelReturnButton")
|
|
|
|
.addEventListener("click", onReturnButtonClick);
|
|
|
|
document
|
|
|
|
.getElementById("copyToClipboardTop")
|
|
|
|
.addEventListener("click", copyPEMToClipboard);
|
|
|
|
document
|
|
|
|
.getElementById("copyToClipboardBottom")
|
|
|
|
.addEventListener("click", copyPEMToClipboard);
|
2019-10-28 23:39:16 +03:00
|
|
|
document
|
|
|
|
.getElementById("exceptionDialogButton")
|
|
|
|
.addEventListener("click", addCertException);
|
2019-06-26 23:24:05 +03:00
|
|
|
}
|
|
|
|
|
2019-10-28 23:39:16 +03:00
|
|
|
function addCertException() {
|
2019-12-19 00:55:32 +03:00
|
|
|
const isPermanent =
|
|
|
|
!RPMIsWindowPrivate() &&
|
|
|
|
RPMGetBoolPref("security.certerrors.permanentOverride");
|
|
|
|
document.addCertException(!isPermanent).then(
|
|
|
|
() => {
|
|
|
|
location.reload();
|
|
|
|
},
|
|
|
|
err => {}
|
|
|
|
);
|
2019-10-28 23:39:16 +03:00
|
|
|
}
|
|
|
|
|
2019-09-05 23:04:03 +03:00
|
|
|
function onReturnButtonClick(e) {
|
|
|
|
RPMSendAsyncMessage("Browser:SSLErrorGoBack");
|
|
|
|
}
|
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
function copyPEMToClipboard(e) {
|
|
|
|
const errorText = document.getElementById("certificateErrorText");
|
|
|
|
navigator.clipboard.writeText(errorText.textContent);
|
2019-06-26 23:24:05 +03:00
|
|
|
}
|
|
|
|
|
2019-09-05 23:04:03 +03:00
|
|
|
async function getFailedCertificatesAsPEMString() {
|
2019-06-26 23:24:05 +03:00
|
|
|
let location = document.location.href;
|
|
|
|
let failedCertInfo = document.getFailedCertSecurityInfo();
|
|
|
|
let errorMessage = failedCertInfo.errorMessage;
|
|
|
|
let hasHSTS = failedCertInfo.hasHSTS.toString();
|
|
|
|
let hasHPKP = failedCertInfo.hasHPKP.toString();
|
2020-07-02 21:51:44 +03:00
|
|
|
let [
|
|
|
|
hstsLabel,
|
|
|
|
hpkpLabel,
|
|
|
|
failedChainLabel,
|
|
|
|
] = await document.l10n.formatValues([
|
2019-06-26 23:24:05 +03:00
|
|
|
{ id: "cert-error-details-hsts-label", args: { hasHSTS } },
|
|
|
|
{ id: "cert-error-details-key-pinning-label", args: { hasHPKP } },
|
2020-07-02 21:51:44 +03:00
|
|
|
{ id: "cert-error-details-cert-chain-label" },
|
2019-06-26 23:24:05 +03:00
|
|
|
]);
|
|
|
|
|
|
|
|
let certStrings = failedCertInfo.certChainStrings;
|
|
|
|
let failedChainCertificates = "";
|
|
|
|
for (let der64 of certStrings) {
|
|
|
|
let wrapped = der64.replace(/(\S{64}(?!$))/g, "$1\r\n");
|
|
|
|
failedChainCertificates +=
|
|
|
|
"-----BEGIN CERTIFICATE-----\r\n" +
|
|
|
|
wrapped +
|
|
|
|
"\r\n-----END CERTIFICATE-----\r\n";
|
|
|
|
}
|
2019-07-05 10:48:57 +03:00
|
|
|
|
2019-06-26 23:24:05 +03:00
|
|
|
let details =
|
|
|
|
location +
|
|
|
|
"\r\n\r\n" +
|
|
|
|
errorMessage +
|
|
|
|
"\r\n\r\n" +
|
|
|
|
hstsLabel +
|
|
|
|
"\r\n" +
|
|
|
|
hpkpLabel +
|
|
|
|
"\r\n\r\n" +
|
|
|
|
failedChainLabel +
|
|
|
|
"\r\n\r\n" +
|
|
|
|
failedChainCertificates;
|
|
|
|
return details;
|
2019-06-18 06:54:21 +03:00
|
|
|
}
|
2019-05-30 09:43:14 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
function setCertErrorDetails() {
|
2019-06-18 06:54:21 +03:00
|
|
|
// Check if the connection is being man-in-the-middled. When the parent
|
|
|
|
// detects an intercepted connection, the page may be reloaded with a new
|
|
|
|
// error code (MOZILLA_PKIX_ERROR_MITM_DETECTED).
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const failedCertInfo = document.getFailedCertSecurityInfo();
|
|
|
|
const mitmPrimingEnabled = RPMGetBoolPref(
|
2019-06-18 06:54:21 +03:00
|
|
|
"security.certerrors.mitm.priming.enabled"
|
|
|
|
);
|
|
|
|
if (
|
|
|
|
mitmPrimingEnabled &&
|
|
|
|
failedCertInfo.errorCodeString == "SEC_ERROR_UNKNOWN_ISSUER" &&
|
|
|
|
// Only do this check for top-level failures.
|
|
|
|
window.parent == window
|
|
|
|
) {
|
|
|
|
RPMSendAsyncMessage("Browser:PrimeMitm");
|
|
|
|
}
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.body.setAttribute("code", failedCertInfo.errorCodeString);
|
2019-06-18 06:54:21 +03:00
|
|
|
|
2022-10-07 21:40:29 +03:00
|
|
|
const learnMore = document.getElementById("learnMoreContainer");
|
|
|
|
learnMore.hidden = false;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const learnMoreLink = document.getElementById("learnMoreLink");
|
|
|
|
const baseURL = RPMGetFormatURLPref("app.support.baseURL");
|
|
|
|
learnMoreLink.href = baseURL + "connection-not-secure";
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const bodyTitle = document.querySelector(".title-text");
|
2022-10-07 21:40:29 +03:00
|
|
|
const shortDesc = document.getElementById("errorShortDesc");
|
|
|
|
const shortDesc2 = document.getElementById("errorShortDesc2");
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
let whatToDoParts = null;
|
2019-06-18 06:54:21 +03:00
|
|
|
|
|
|
|
switch (failedCertInfo.errorCodeString) {
|
|
|
|
case "SSL_ERROR_BAD_CERT_DOMAIN":
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
whatToDoParts = [
|
|
|
|
["p", "certerror-bad-cert-domain-what-can-you-do-about-it"],
|
|
|
|
];
|
|
|
|
break;
|
|
|
|
|
|
|
|
case "SEC_ERROR_OCSP_INVALID_SIGNING_CERT": // FIXME - this would have thrown?
|
|
|
|
break;
|
|
|
|
|
2019-06-18 06:54:21 +03:00
|
|
|
case "SEC_ERROR_UNKNOWN_ISSUER":
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
whatToDoParts = [
|
|
|
|
["p", "certerror-unknown-issuer-what-can-you-do-about-it-website"],
|
|
|
|
[
|
|
|
|
"p",
|
|
|
|
"certerror-unknown-issuer-what-can-you-do-about-it-contact-admin",
|
|
|
|
],
|
|
|
|
];
|
2019-06-18 06:54:21 +03:00
|
|
|
break;
|
|
|
|
|
|
|
|
// This error code currently only exists for the Symantec distrust
|
|
|
|
// in Firefox 63, so we add copy explaining that to the user.
|
|
|
|
// In case of future distrusts of that scale we might need to add
|
|
|
|
// additional parameters that allow us to identify the affected party
|
|
|
|
// without replicating the complex logic from certverifier code.
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
case "MOZILLA_PKIX_ERROR_ADDITIONAL_POLICY_CONSTRAINT_FAILED": {
|
2019-06-18 06:54:21 +03:00
|
|
|
document.l10n.setAttributes(
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
shortDesc2,
|
2019-06-18 06:54:21 +03:00
|
|
|
"cert-error-symantec-distrust-description",
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
{ hostname: HOST_NAME }
|
2019-06-18 06:54:21 +03:00
|
|
|
);
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// FIXME - this does nothing
|
|
|
|
const adminDesc = document.createElement("p");
|
2019-06-18 06:54:21 +03:00
|
|
|
document.l10n.setAttributes(
|
|
|
|
adminDesc,
|
|
|
|
"cert-error-symantec-distrust-admin"
|
|
|
|
);
|
|
|
|
|
|
|
|
learnMoreLink.href = baseURL + "symantec-warning";
|
|
|
|
break;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
}
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
case "MOZILLA_PKIX_ERROR_MITM_DETECTED": {
|
|
|
|
const autoEnabledEnterpriseRoots = RPMGetBoolPref(
|
2019-07-25 01:07:12 +03:00
|
|
|
"security.enterprise_roots.auto-enabled",
|
|
|
|
false
|
2019-06-18 06:54:21 +03:00
|
|
|
);
|
|
|
|
if (mitmPrimingEnabled && autoEnabledEnterpriseRoots) {
|
|
|
|
RPMSendAsyncMessage("Browser:ResetEnterpriseRootsPref");
|
|
|
|
}
|
|
|
|
|
|
|
|
learnMoreLink.href = baseURL + "security-error";
|
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(bodyTitle, "certerror-mitm-title");
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(shortDesc, "certerror-mitm", {
|
|
|
|
hostname: HOST_NAME,
|
|
|
|
mitm: getMitmName(failedCertInfo),
|
|
|
|
});
|
|
|
|
|
|
|
|
const id3 = gHasSts
|
|
|
|
? "certerror-mitm-what-can-you-do-about-it-attack-sts"
|
|
|
|
: "certerror-mitm-what-can-you-do-about-it-attack";
|
|
|
|
whatToDoParts = [
|
|
|
|
["li", "certerror-mitm-what-can-you-do-about-it-antivirus"],
|
|
|
|
["li", "certerror-mitm-what-can-you-do-about-it-corporate"],
|
|
|
|
["li", id3, { mitm: getMitmName(failedCertInfo) }],
|
|
|
|
];
|
2019-06-18 06:54:21 +03:00
|
|
|
break;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
}
|
2019-06-18 06:54:21 +03:00
|
|
|
|
|
|
|
case "MOZILLA_PKIX_ERROR_SELF_SIGNED_CERT":
|
|
|
|
learnMoreLink.href = baseURL + "security-error";
|
|
|
|
break;
|
|
|
|
|
|
|
|
// In case the certificate expired we make sure the system clock
|
|
|
|
// matches the remote-settings service (blocklist via Kinto) ping time
|
|
|
|
// and is not before the build date.
|
|
|
|
case "SEC_ERROR_EXPIRED_CERTIFICATE":
|
|
|
|
case "SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE":
|
|
|
|
case "MOZILLA_PKIX_ERROR_NOT_YET_VALID_CERTIFICATE":
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
case "MOZILLA_PKIX_ERROR_NOT_YET_VALID_ISSUER_CERTIFICATE": {
|
2019-06-18 06:54:21 +03:00
|
|
|
learnMoreLink.href = baseURL + "time-errors";
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
|
2019-06-18 06:54:21 +03:00
|
|
|
// We check against the remote-settings server time first if available, because that allows us
|
|
|
|
// to give the user an approximation of what the correct time is.
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const difference = RPMGetIntPref(
|
|
|
|
"services.settings.clock_skew_seconds",
|
|
|
|
0
|
|
|
|
);
|
|
|
|
const lastFetched =
|
2019-07-25 01:07:12 +03:00
|
|
|
RPMGetIntPref("services.settings.last_update_seconds", 0) * 1000;
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// This is set to true later if the user's system clock is at fault for this error.
|
|
|
|
let clockSkew = false;
|
|
|
|
|
|
|
|
const now = Date.now();
|
|
|
|
const certRange = {
|
2019-06-18 06:54:21 +03:00
|
|
|
notBefore: failedCertInfo.certValidityRangeNotBefore,
|
|
|
|
notAfter: failedCertInfo.certValidityRangeNotAfter,
|
|
|
|
};
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const approximateDate = now - difference * 1000;
|
2019-06-18 06:54:21 +03:00
|
|
|
// If the difference is more than a day, we last fetched the date in the last 5 days,
|
|
|
|
// and adjusting the date per the interval would make the cert valid, warn the user:
|
|
|
|
if (
|
|
|
|
Math.abs(difference) > 60 * 60 * 24 &&
|
2020-03-26 16:36:19 +03:00
|
|
|
now - lastFetched <= 60 * 60 * 24 * 5 * 1000 &&
|
2019-06-18 06:54:21 +03:00
|
|
|
certRange.notBefore < approximateDate &&
|
|
|
|
certRange.notAfter > approximateDate
|
|
|
|
) {
|
|
|
|
clockSkew = true;
|
|
|
|
// If there is no clock skew with Kinto servers, check against the build date.
|
|
|
|
// (The Kinto ping could have happened when the time was still right, or not at all)
|
|
|
|
} else {
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const appBuildID = RPMGetAppBuildID();
|
|
|
|
const year = parseInt(appBuildID.substr(0, 4), 10);
|
|
|
|
const month = parseInt(appBuildID.substr(4, 2), 10) - 1;
|
|
|
|
const day = parseInt(appBuildID.substr(6, 2), 10);
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
const buildDate = new Date(year, month, day);
|
2019-06-18 06:54:21 +03:00
|
|
|
|
|
|
|
// We don't check the notBefore of the cert with the build date,
|
|
|
|
// as it is of course almost certain that it is now later than the build date,
|
|
|
|
// so we shouldn't exclude the possibility that the cert has become valid
|
|
|
|
// since the build date.
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
if (buildDate > now && new Date(certRange.notAfter) > buildDate) {
|
2019-06-18 06:54:21 +03:00
|
|
|
clockSkew = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clockSkew) {
|
2021-12-23 00:41:40 +03:00
|
|
|
document.body.classList.add("clockSkewError");
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(bodyTitle, "clockSkewError-title");
|
|
|
|
document.l10n.setAttributes(shortDesc, "neterror-clock-skew-error", {
|
|
|
|
hostname: HOST_NAME,
|
|
|
|
now,
|
|
|
|
});
|
2022-10-07 21:40:29 +03:00
|
|
|
document.getElementById("returnButton").hidden = true;
|
|
|
|
document.getElementById("certErrorTryAgainButton").hidden = false;
|
|
|
|
document.getElementById("advancedButton").hidden = true;
|
|
|
|
|
|
|
|
document.getElementById("advancedPanelReturnButton").hidden = true;
|
|
|
|
document.getElementById("advancedPanelTryAgainButton").hidden = false;
|
|
|
|
document.getElementById("exceptionDialogButton").hidden = true;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
break;
|
|
|
|
}
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
document.l10n.setAttributes(shortDesc, "certerror-expired-cert-intro", {
|
|
|
|
hostname: HOST_NAME,
|
|
|
|
});
|
2019-06-18 06:54:21 +03:00
|
|
|
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
// The secondary description mentions expired certificates explicitly
|
|
|
|
// and should only be shown if the certificate has actually expired
|
|
|
|
// instead of being not yet valid.
|
|
|
|
if (failedCertInfo.errorCodeString == "SEC_ERROR_EXPIRED_CERTIFICATE") {
|
|
|
|
const sd2Id = gHasSts
|
|
|
|
? "certerror-expired-cert-sts-second-para"
|
|
|
|
: "certerror-expired-cert-second-para";
|
|
|
|
document.l10n.setAttributes(shortDesc2, sd2Id);
|
|
|
|
if (
|
|
|
|
Math.abs(difference) <= 60 * 60 * 24 &&
|
|
|
|
now - lastFetched <= 60 * 60 * 24 * 5 * 1000
|
|
|
|
) {
|
|
|
|
whatToDoParts = [
|
|
|
|
["p", "certerror-bad-cert-domain-what-can-you-do-about-it"],
|
|
|
|
];
|
2019-06-18 06:54:21 +03:00
|
|
|
}
|
|
|
|
}
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
|
|
|
|
whatToDoParts ??= [
|
|
|
|
[
|
|
|
|
"p",
|
|
|
|
"certerror-expired-cert-what-can-you-do-about-it-clock",
|
|
|
|
{ hostname: HOST_NAME, now },
|
|
|
|
],
|
|
|
|
[
|
|
|
|
"p",
|
|
|
|
"certerror-expired-cert-what-can-you-do-about-it-contact-website",
|
|
|
|
],
|
|
|
|
];
|
2019-06-18 06:54:21 +03:00
|
|
|
break;
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (whatToDoParts) {
|
2022-10-07 21:40:29 +03:00
|
|
|
setNetErrorMessageFromParts(
|
|
|
|
document.getElementById("errorWhatToDoText"),
|
|
|
|
whatToDoParts
|
Bug 1734217 - Migrate aboutNetError from DTD to Fluent. r=fluent-reviewers,prathiksha,flod
To support and enable the migration, quite a bit of refactoring is needed.
Many of the localised error messages are in fact fragments of HTML, including messages with nesting not supported by Fluent. In the FTL, these have each been split up into multiple messages using a custom migration transform (included directly in the script). This allows for localisers to work with the messages without HTML syntax, but does require the messages' structures to be maintained elsewhere. To that effect, the JS file represents messages as arrays of `[tagName, l10nId, l10nArgs]` tuples from which it builds the messages' elements. This fixex bug 1621895.
Though extensive, the refactoring done here is for the most part limited to what's required by the Fluent migration. For instance, not all issues raised in bug 1722896 are resolved here. Places where the structure was sufficiently messy to have introduced bugs or dead code have been cleaned up a bit, though.
This variant of netError that's used by the browser is not itself overridden by anyone else, which allows for it to be tackled first and independently of the docshell and mobile variants. As a part of its content is still passed in as a query parameter, it's possible that later refactors of the rest of the netError system will allow for further clean-up here.
Differential Revision: https://phabricator.services.mozilla.com/D155951
2022-10-07 21:40:27 +03:00
|
|
|
);
|
2022-10-07 21:40:29 +03:00
|
|
|
document.getElementById("errorWhatToDo").hidden = false;
|
2019-06-18 06:54:21 +03:00
|
|
|
}
|
2019-05-30 09:43:14 +03:00
|
|
|
}
|
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
async function getSubjectAltNames(failedCertInfo) {
|
|
|
|
const serverCertBase64 = failedCertInfo.certChainStrings[0];
|
|
|
|
const parsed = await parse(pemToDER(serverCertBase64));
|
|
|
|
const subjectAltNamesExtension = parsed.ext.san;
|
|
|
|
const subjectAltNames = [];
|
|
|
|
if (subjectAltNamesExtension) {
|
|
|
|
for (let [key, value] of subjectAltNamesExtension.altNames) {
|
|
|
|
if (key === "DNS Name" && value.length) {
|
|
|
|
subjectAltNames.push(value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return subjectAltNames;
|
|
|
|
}
|
|
|
|
|
2020-09-02 04:50:06 +03:00
|
|
|
// The optional argument is only here for testing purposes.
|
2022-10-12 15:34:36 +03:00
|
|
|
function setTechnicalDetailsOnCertError(
|
2020-09-02 04:50:06 +03:00
|
|
|
failedCertInfo = document.getFailedCertSecurityInfo()
|
|
|
|
) {
|
2019-05-30 09:43:14 +03:00
|
|
|
let technicalInfo = document.getElementById("badCertTechnicalInfo");
|
2022-10-07 21:40:29 +03:00
|
|
|
technicalInfo.textContent = "";
|
2019-05-30 09:43:14 +03:00
|
|
|
|
2022-10-07 21:40:29 +03:00
|
|
|
function addLabel(l10nId, args = null, attrs = null) {
|
2019-05-30 09:43:14 +03:00
|
|
|
let elem = document.createElement("label");
|
|
|
|
technicalInfo.appendChild(elem);
|
|
|
|
|
|
|
|
let newLines = document.createTextNode("\n \n");
|
|
|
|
technicalInfo.appendChild(newLines);
|
|
|
|
|
|
|
|
if (attrs) {
|
|
|
|
let link = document.createElement("a");
|
2022-10-07 21:40:29 +03:00
|
|
|
for (let [attr, value] of Object.entries(attrs)) {
|
|
|
|
link.setAttribute(attr, value);
|
2019-05-30 09:43:14 +03:00
|
|
|
}
|
|
|
|
elem.appendChild(link);
|
|
|
|
}
|
|
|
|
|
2022-10-07 21:40:29 +03:00
|
|
|
document.l10n.setAttributes(elem, l10nId, args);
|
2019-05-30 09:43:14 +03:00
|
|
|
}
|
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
function addErrorCodeLink() {
|
|
|
|
addLabel(
|
|
|
|
"cert-error-code-prefix-link",
|
|
|
|
{ error: failedCertInfo.errorCodeString },
|
|
|
|
{
|
|
|
|
title: failedCertInfo.errorCodeString,
|
|
|
|
id: "errorCode",
|
|
|
|
"data-l10n-name": "error-code-link",
|
|
|
|
"data-telemetry-id": "error_code_link",
|
|
|
|
href: "#certificateErrorDebugInformation",
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
|
|
|
// We're attaching the event listener to the parent element and not on
|
|
|
|
// the errorCodeLink itself because event listeners cannot be attached
|
|
|
|
// to fluent DOM overlays.
|
|
|
|
technicalInfo.addEventListener("click", event => {
|
|
|
|
if (event.target.id === "errorCode") {
|
|
|
|
event.preventDefault();
|
|
|
|
toggleCertErrorDebugInfoVisibility();
|
|
|
|
recordClickTelemetry(event);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2019-05-30 09:43:14 +03:00
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
let hostname = HOST_NAME;
|
|
|
|
const { port } = document.location;
|
2019-05-30 09:43:14 +03:00
|
|
|
if (port && port != 443) {
|
2022-10-12 15:34:36 +03:00
|
|
|
hostname += ":" + port;
|
2019-05-30 09:43:14 +03:00
|
|
|
}
|
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
switch (failedCertInfo.overridableErrorCategory) {
|
|
|
|
case "trust-error":
|
|
|
|
switch (failedCertInfo.errorCodeString) {
|
|
|
|
case "MOZILLA_PKIX_ERROR_MITM_DETECTED":
|
|
|
|
addLabel("cert-error-mitm-intro");
|
|
|
|
addLabel("cert-error-mitm-mozilla");
|
|
|
|
addLabel("cert-error-mitm-connection");
|
|
|
|
break;
|
|
|
|
case "SEC_ERROR_UNKNOWN_ISSUER":
|
|
|
|
addLabel("cert-error-trust-unknown-issuer-intro");
|
|
|
|
addLabel("cert-error-trust-unknown-issuer", { hostname });
|
|
|
|
break;
|
|
|
|
case "SEC_ERROR_CA_CERT_INVALID":
|
|
|
|
addLabel("cert-error-intro", { hostname });
|
|
|
|
addLabel("cert-error-trust-cert-invalid");
|
|
|
|
break;
|
|
|
|
case "SEC_ERROR_UNTRUSTED_ISSUER":
|
|
|
|
addLabel("cert-error-intro", { hostname });
|
|
|
|
addLabel("cert-error-trust-untrusted-issuer");
|
|
|
|
break;
|
|
|
|
case "SEC_ERROR_CERT_SIGNATURE_ALGORITHM_DISABLED":
|
|
|
|
addLabel("cert-error-intro", { hostname });
|
|
|
|
addLabel("cert-error-trust-signature-algorithm-disabled");
|
|
|
|
break;
|
|
|
|
case "SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE":
|
|
|
|
addLabel("cert-error-intro", { hostname });
|
|
|
|
addLabel("cert-error-trust-expired-issuer");
|
|
|
|
break;
|
|
|
|
case "MOZILLA_PKIX_ERROR_SELF_SIGNED_CERT":
|
|
|
|
addLabel("cert-error-intro", { hostname });
|
|
|
|
addLabel("cert-error-trust-self-signed");
|
|
|
|
break;
|
|
|
|
case "MOZILLA_PKIX_ERROR_ADDITIONAL_POLICY_CONSTRAINT_FAILED":
|
|
|
|
addLabel("cert-error-intro", { hostname });
|
|
|
|
addLabel("cert-error-trust-symantec");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
addLabel("cert-error-intro", { hostname });
|
|
|
|
addLabel("cert-error-untrusted-default");
|
2021-01-14 12:58:03 +03:00
|
|
|
}
|
2022-10-12 15:34:36 +03:00
|
|
|
addErrorCodeLink();
|
|
|
|
break;
|
2019-07-05 10:48:57 +03:00
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
case "expired-or-not-yet-valid": {
|
|
|
|
const notBefore = failedCertInfo.validNotBefore;
|
|
|
|
const notAfter = failedCertInfo.validNotAfter;
|
|
|
|
if (notBefore && Date.now() < notAfter) {
|
|
|
|
addLabel("cert-error-not-yet-valid-now", {
|
|
|
|
hostname,
|
|
|
|
"not-before-local-time": formatter.format(new Date(notBefore)),
|
|
|
|
});
|
2019-05-30 09:43:14 +03:00
|
|
|
} else {
|
2022-10-12 15:34:36 +03:00
|
|
|
addLabel("cert-error-expired-now", {
|
|
|
|
hostname,
|
|
|
|
"not-after-local-time": formatter.format(new Date(notAfter)),
|
|
|
|
});
|
2019-05-30 09:43:14 +03:00
|
|
|
}
|
2022-10-12 15:34:36 +03:00
|
|
|
addErrorCodeLink();
|
|
|
|
break;
|
2019-05-30 09:43:14 +03:00
|
|
|
}
|
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
case "domain-mismatch":
|
|
|
|
getSubjectAltNames(failedCertInfo).then(subjectAltNames => {
|
|
|
|
if (!subjectAltNames.length) {
|
|
|
|
addLabel("cert-error-domain-mismatch", { hostname });
|
|
|
|
} else if (subjectAltNames.length > 1) {
|
|
|
|
const names = subjectAltNames.join(", ");
|
|
|
|
addLabel("cert-error-domain-mismatch-multiple", {
|
|
|
|
hostname,
|
|
|
|
"subject-alt-names": names,
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
const altName = subjectAltNames[0];
|
|
|
|
|
|
|
|
// If the alt name is a wildcard domain ("*.example.com")
|
|
|
|
// let's use "www" instead. "*.example.com" isn't going to
|
|
|
|
// get anyone anywhere useful. bug 432491
|
|
|
|
const okHost = altName.replace(/^\*\./, "www.");
|
|
|
|
|
|
|
|
// Let's check if we want to make this a link.
|
|
|
|
const showLink =
|
|
|
|
/* case #1:
|
|
|
|
* example.com uses an invalid security certificate.
|
|
|
|
*
|
|
|
|
* The certificate is only valid for www.example.com
|
|
|
|
*
|
|
|
|
* Make sure to include the "." ahead of thisHost so that a
|
|
|
|
* MitM attack on paypal.com doesn't hyperlink to "notpaypal.com"
|
|
|
|
*
|
|
|
|
* We'd normally just use a RegExp here except that we lack a
|
|
|
|
* library function to escape them properly (bug 248062), and
|
|
|
|
* domain names are famous for having '.' characters in them,
|
|
|
|
* which would allow spurious and possibly hostile matches.
|
|
|
|
*/
|
|
|
|
okHost.endsWith("." + HOST_NAME) ||
|
|
|
|
/* case #2:
|
|
|
|
* browser.garage.maemo.org uses an invalid security certificate.
|
|
|
|
*
|
|
|
|
* The certificate is only valid for garage.maemo.org
|
|
|
|
*/
|
|
|
|
HOST_NAME.endsWith("." + okHost);
|
|
|
|
|
|
|
|
const l10nArgs = { hostname, "alt-name": altName };
|
|
|
|
if (showLink) {
|
|
|
|
// Set the link if we want it.
|
|
|
|
const proto = document.location.protocol + "//";
|
|
|
|
addLabel("cert-error-domain-mismatch-single", l10nArgs, {
|
|
|
|
href: proto + okHost,
|
|
|
|
"data-l10n-name": "domain-mismatch-link",
|
|
|
|
id: "cert_domain_link",
|
|
|
|
});
|
|
|
|
|
|
|
|
// If we set a link, meaning there's something helpful for
|
|
|
|
// the user here, expand the section by default
|
|
|
|
if (getCSSClass() != "expertBadCert") {
|
|
|
|
document.getElementById("badCertAdvancedPanel").hidden = false;
|
|
|
|
|
|
|
|
// Toggling the advanced panel must ensure that the debugging
|
|
|
|
// information panel is hidden as well, since it's opened by the
|
|
|
|
// error code link in the advanced panel.
|
|
|
|
toggleCertErrorDebugInfoVisibility(false);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addLabel("cert-error-domain-mismatch-single-nolink", l10nArgs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
addErrorCodeLink();
|
|
|
|
});
|
|
|
|
break;
|
2019-05-30 09:43:14 +03:00
|
|
|
}
|
2020-02-20 15:59:05 +03:00
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
getFailedCertificatesAsPEMString().then(pemString => {
|
|
|
|
const errorText = document.getElementById("certificateErrorText");
|
|
|
|
errorText.textContent = pemString;
|
|
|
|
});
|
2018-04-26 11:07:07 +03:00
|
|
|
}
|
|
|
|
|
2021-05-21 21:13:29 +03:00
|
|
|
/* Only focus if we're the toplevel frame; otherwise we
|
|
|
|
don't want to call attention to ourselves!
|
2018-04-26 11:07:07 +03:00
|
|
|
*/
|
2021-05-21 21:13:29 +03:00
|
|
|
function setFocus(selector, position = "afterbegin") {
|
2018-04-26 11:07:07 +03:00
|
|
|
if (window.top == window) {
|
2019-05-13 22:38:03 +03:00
|
|
|
var button = document.querySelector(selector);
|
2018-04-26 11:07:07 +03:00
|
|
|
var parent = button.parentNode;
|
|
|
|
parent.insertAdjacentElement(position, button);
|
2021-05-21 21:13:29 +03:00
|
|
|
// It's possible setFocus was called via the DOMContentLoaded event
|
|
|
|
// handler and that the button has no frame. Things without a frame cannot
|
|
|
|
// be focused. We use a requestAnimationFrame to queue up the focus to occur
|
|
|
|
// once the button has its frame.
|
|
|
|
requestAnimationFrame(() => {
|
2022-07-12 01:04:34 +03:00
|
|
|
button.focus({ focusVisible: false });
|
2021-05-21 21:13:29 +03:00
|
|
|
});
|
2018-04-26 11:07:07 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-13 22:38:03 +03:00
|
|
|
for (let button of document.querySelectorAll(".try-again")) {
|
|
|
|
button.addEventListener("click", function() {
|
|
|
|
retryThis(this);
|
|
|
|
});
|
|
|
|
}
|
2018-08-02 20:29:04 +03:00
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
initPage();
|
2021-01-14 12:58:03 +03:00
|
|
|
|
2022-10-12 15:34:36 +03:00
|
|
|
// Dispatch this event so tests can detect that we finished loading the error page.
|
|
|
|
const event = new CustomEvent("AboutNetErrorLoad", { bubbles: true });
|
|
|
|
document.dispatchEvent(event);
|