|
|
|
|
SSL URILoadingHelper.sys.mjs
Sprache: unbekannt
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
import { BrowserUtils } from "resource://gre/modules/BrowserUtils.sys.mjs";
import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs";
const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
AboutNewTab: "resource:///modules/AboutNewTab.sys.mjs",
BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.sys.mjs",
});
ChromeUtils.defineLazyGetter(lazy, "ReferrerInfo", () =>
Components.Constructor(
"@mozilla.org/referrer-info;1",
"nsIReferrerInfo",
"init"
)
);
function saveLink(window, url, params) {
if ("isContentWindowPrivate" in params) {
window.saveURL(
url,
null,
null,
null,
true,
true,
params.referrerInfo,
null,
null,
params.isContentWindowPrivate,
params.originPrincipal
);
} else {
if (!params.initiatingDoc) {
console.error(
"openUILink/openLinkIn was called with " +
"where == 'save' but without initiatingDoc. See bug 814264."
);
return;
}
window.saveURL(
url,
null,
null,
null,
true,
true,
params.referrerInfo,
null,
params.initiatingDoc
);
}
}
function openInWindow(url, params, sourceWindow) {
let {
referrerInfo,
forceNonPrivate,
triggeringRemoteType,
forceAllowDataURI,
globalHistoryOptions,
allowThirdPartyFixup,
userContextId,
postData,
originPrincipal,
originStoragePrincipal,
triggeringPrincipal,
csp,
resolveOnContentBrowserCreated,
} = params;
let features = "chrome,dialog=no,all";
if (params.private) {
features += ",private";
// To prevent regular browsing data from leaking to private browsing sites,
// strip the referrer when opening a new private window. (See Bug: 1409226)
referrerInfo = new lazy.ReferrerInfo(
referrerInfo.referrerPolicy,
false,
referrerInfo.originalReferrer
);
} else if (forceNonPrivate) {
features += ",non-private";
}
// This propagates to window.arguments.
var sa = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
var wuri = Cc["@mozilla.org/supports-string;1"].createInstance(
Ci.nsISupportsString
);
wuri.data = url;
let extraOptions = Cc["@mozilla.org/hash-property-bag;1"].createInstance(
Ci.nsIWritablePropertyBag2
);
if (triggeringRemoteType) {
extraOptions.setPropertyAsACString(
"triggeringRemoteType",
triggeringRemoteType
);
}
if (params.hasValidUserGestureActivation !== undefined) {
extraOptions.setPropertyAsBool(
"hasValidUserGestureActivation",
params.hasValidUserGestureActivation
);
}
if (forceAllowDataURI) {
extraOptions.setPropertyAsBool("forceAllowDataURI", true);
}
if (params.fromExternal !== undefined) {
extraOptions.setPropertyAsBool("fromExternal", params.fromExternal);
}
if (globalHistoryOptions?.triggeringSponsoredURL) {
extraOptions.setPropertyAsACString(
"triggeringSponsoredURL",
globalHistoryOptions.triggeringSponsoredURL
);
if (globalHistoryOptions.triggeringSponsoredURLVisitTimeMS) {
extraOptions.setPropertyAsUint64(
"triggeringSponsoredURLVisitTimeMS",
globalHistoryOptions.triggeringSponsoredURLVisitTimeMS
);
}
}
if (params.schemelessInput !== undefined) {
extraOptions.setPropertyAsUint32("schemelessInput", params.schemelessInput);
}
var allowThirdPartyFixupSupports = Cc[
"@mozilla.org/supports-PRBool;1"
].createInstance(Ci.nsISupportsPRBool);
allowThirdPartyFixupSupports.data = allowThirdPartyFixup;
var userContextIdSupports = Cc[
"@mozilla.org/supports-PRUint32;1"
].createInstance(Ci.nsISupportsPRUint32);
userContextIdSupports.data = userContextId;
sa.appendElement(wuri);
sa.appendElement(extraOptions);
sa.appendElement(referrerInfo);
sa.appendElement(postData);
sa.appendElement(allowThirdPartyFixupSupports);
sa.appendElement(userContextIdSupports);
sa.appendElement(originPrincipal);
sa.appendElement(originStoragePrincipal);
sa.appendElement(triggeringPrincipal);
sa.appendElement(null); // allowInheritPrincipal
sa.appendElement(csp);
let win;
// Returns a promise that will be resolved when the new window's startup is finished.
function waitForWindowStartup() {
return new Promise(resolve => {
const delayedStartupObserver = aSubject => {
if (aSubject == win) {
Services.obs.removeObserver(
delayedStartupObserver,
"browser-delayed-startup-finished"
);
resolve();
}
};
Services.obs.addObserver(
delayedStartupObserver,
"browser-delayed-startup-finished"
);
});
}
if (params.frameID != undefined && sourceWindow) {
// Only notify it as a WebExtensions' webNavigation.onCreatedNavigationTarget
// event if it contains the expected frameID params.
// (e.g. we should not notify it as a onCreatedNavigationTarget if the user is
// opening a new window using the keyboard shortcut).
const sourceTabBrowser = sourceWindow.gBrowser.selectedBrowser;
waitForWindowStartup().then(() => {
Services.obs.notifyObservers(
{
wrappedJSObject: {
url,
createdTabBrowser: win.gBrowser.selectedBrowser,
sourceTabBrowser,
sourceFrameID: params.frameID,
},
},
"webNavigation-createdNavigationTarget"
);
});
}
if (resolveOnContentBrowserCreated) {
waitForWindowStartup().then(() =>
resolveOnContentBrowserCreated(win.gBrowser.selectedBrowser)
);
}
win = Services.ww.openWindow(
sourceWindow,
AppConstants.BROWSER_CHROME_URL,
null,
features,
sa
);
}
function openInCurrentTab(targetBrowser, url, uriObj, params) {
let loadFlags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
if (params.allowThirdPartyFixup) {
loadFlags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
loadFlags |= Ci.nsIWebNavigation.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
}
// LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL isn't supported for javascript URIs,
// i.e. it causes them not to load at all. Callers should strip
// "javascript:" from pasted strings to prevent blank tabs
if (!params.allowInheritPrincipal) {
loadFlags |= Ci.nsIWebNavigation.LOAD_FLAGS_DISALLOW_INHERIT_PRINCIPAL;
}
if (params.allowPopups) {
loadFlags |= Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_POPUPS;
}
if (params.indicateErrorPageLoad) {
loadFlags |= Ci.nsIWebNavigation.LOAD_FLAGS_ERROR_LOAD_CHANGES_RV;
}
if (params.forceAllowDataURI) {
loadFlags |= Ci.nsIWebNavigation.LOAD_FLAGS_FORCE_ALLOW_DATA_URI;
}
if (params.fromExternal) {
loadFlags |= Ci.nsIWebNavigation.LOAD_FLAGS_FROM_EXTERNAL;
}
let { URI_INHERITS_SECURITY_CONTEXT } = Ci.nsIProtocolHandler;
if (
params.forceAboutBlankViewerInCurrent &&
(!uriObj ||
Services.io.getDynamicProtocolFlags(uriObj) &
URI_INHERITS_SECURITY_CONTEXT)
) {
// Unless we know for sure we're not inheriting principals,
// force the about:blank viewer to have the right principal:
targetBrowser.createAboutBlankDocumentViewer(
params.originPrincipal,
params.originStoragePrincipal
);
}
let {
triggeringPrincipal,
csp,
referrerInfo,
postData,
userContextId,
hasValidUserGestureActivation,
globalHistoryOptions,
triggeringRemoteType,
schemelessInput,
} = params;
targetBrowser.fixupAndLoadURIString(url, {
triggeringPrincipal,
csp,
loadFlags,
referrerInfo,
postData,
userContextId,
hasValidUserGestureActivation,
globalHistoryOptions,
triggeringRemoteType,
schemelessInput,
});
params.resolveOnContentBrowserCreated?.(targetBrowser);
}
function updatePrincipals(window, params) {
let { userContextId } = params;
// Teach the principal about the right OA to use, e.g. in case when
// opening a link in a new private window, or in a new container tab.
// Please note we do not have to do that for SystemPrincipals and we
// can not do it for NullPrincipals since NullPrincipals are only
// identical if they actually are the same object (See Bug: 1346759)
function useOAForPrincipal(principal) {
if (principal && principal.isContentPrincipal) {
let privateBrowsingId =
params.private ||
(window && PrivateBrowsingUtils.isWindowPrivate(window));
let attrs = {
userContextId,
privateBrowsingId,
firstPartyDomain: principal.originAttributes.firstPartyDomain,
};
return Services.scriptSecurityManager.principalWithOA(principal, attrs);
}
return principal;
}
params.originPrincipal = useOAForPrincipal(params.originPrincipal);
params.originStoragePrincipal = useOAForPrincipal(
params.originStoragePrincipal
);
params.triggeringPrincipal = useOAForPrincipal(params.triggeringPrincipal);
}
export const URILoadingHelper = {
/* openLinkIn opens a URL in a place specified by the parameter |where|.
*
* The params object is the same as for `openLinkIn` and documented below.
*
* @param {String} where
* |where| can be:
* "current" current tab (if there aren't any browser windows, then in a new window instead)
* "tab" new tab (if there aren't any browser windows, then in a new window instead)
* "tabshifted" same as "tab" but in background if default is to select new tabs, and vice versa
* "window" new window
* "save" save to disk (with no filename hint!)
*
* @param {Object} params
*
* Options relating to what tab/window to use and how to open it:
*
* @param {boolean} params.private
* Load the URL in a private window.
* @param {boolean} params.forceNonPrivate
* Force the load to happen in non-private windows.
* @param {boolean} params.relatedToCurrent
* Whether new tabs should go immediately next to the current tab.
* @param {Element} params.targetBrowser
* The browser to use for the load. Only used if where == "current".
* @param {boolean} params.inBackground
* If explicitly true or false, whether to switch to the tab immediately.
* If null, will switch to the tab if `forceForeground` was true. If
* neither is passed, will defer to the user preference browser.tabs.loadInBackground.
* @param {boolean} params.forceForeground
* Ignore the user preference and load in the foreground.
* @param {boolean} params.allowPinnedTabHostChange
* Allow even a pinned tab to change hosts.
* @param {boolean} params.allowPopups
* whether the link is allowed to open in a popup window (ie one with no browser
* chrome)
* @param {boolean} params.skipTabAnimation
* Skip the tab opening animation.
* @param {Element} params.openerBrowser
* The browser that started the load.
* @param {boolean} params.avoidBrowserFocus
* Don't focus the browser element immediately after starting
* the load. Used by the URL bar to avoid leaking user input
* into web content, see bug 1641287.
*
* Options relating to the load itself:
*
* @param {boolean} params.allowThirdPartyFixup
* Allow transforming the 'url' into a search query.
* @param {nsIInputStream} params.postData
* Data to post as part of the request.
* @param {nsIReferrerInfo} params.referrerInfo
* Referrer info for the request.
* @param {boolean} params.indicateErrorPageLoad
* Whether docshell should throw an exception (i.e. return non-NS_OK)
* if the load fails.
* @param {string} params.charset
* Character set to use for the load. Only honoured for tabs.
* Legacy argument - do not use.
* @param {SchemelessInputType} params.schemelessInput
* Whether the search/URL term was without an explicit scheme.
*
* Options relating to security, whether the load is allowed to happen,
* and what cookie container to use for the load:
*
* @param {boolean} params.forceAllowDataURI
* Force allow a data URI to load as a toplevel load.
* @param {number} params.userContextId
* The userContextId (container identifier) to use for the load.
* @param {boolean} params.allowInheritPrincipal
* Allow the load to inherit the triggering principal.
* @param {boolean} params.forceAboutBlankViewerInCurrent
* Force load an about:blank page first. Only used if
* allowInheritPrincipal is passed or no URL was provided.
* @param {nsIPrincipal} params.triggeringPrincipal
* Triggering principal to pass to docshell for the load.
* @param {nsIPrincipal} params.originPrincipal
* Origin principal to pass to docshell for the load.
* @param {nsIPrincipal} params.originStoragePrincipal
* Storage principal to pass to docshell for the load.
* @param {string} params.triggeringRemoteType
* The remoteType triggering this load.
* @param {nsIContentSecurityPolicy} params.csp
* The CSP that should apply to the load.
* @param {boolean} params.hasValidUserGestureActivation
* Indicates if a valid user gesture caused this load. This
* informs e.g. popup blocker decisions.
* @param {boolean} params.fromExternal
* Indicates the load was started outside of the browser,
* e.g. passed on the commandline or through OS mechanisms.
*
* Options used to track the load elsewhere
*
* @param {function} params.resolveOnNewTabCreated
* This callback will be called when a new tab is created.
* @param {function} params.resolveOnContentBrowserCreated
* This callback will be called with the content browser once it's created.
* @param {Object} params.globalHistoryOptions
* Used by places to keep track of search related metadata for loads.
* @param {Number} params.frameID
* Used by webextensions for their loads.
*
* Options used for where="save" only:
*
* @param {boolean} params.isContentWindowPrivate
* Save content as coming from a private window.
* @param {Document} params.initiatingDoc
* Used to determine where to prompt for a filename.
*/
openLinkIn(window, url, where, params) {
if (!where || !url) {
return;
}
let {
allowThirdPartyFixup,
postData,
charset,
relatedToCurrent,
allowInheritPrincipal,
forceAllowDataURI,
forceNonPrivate,
skipTabAnimation,
allowPinnedTabHostChange,
userContextId,
triggeringPrincipal,
originPrincipal,
originStoragePrincipal,
triggeringRemoteType,
csp,
resolveOnNewTabCreated,
resolveOnContentBrowserCreated,
globalHistoryOptions,
hasValidUserGestureActivation,
textDirectiveUserActivation,
} = params;
// We want to overwrite some things for convenience when passing it to other
// methods. To avoid impacting callers, copy the params.
params = Object.assign({}, params);
if (!params.referrerInfo) {
params.referrerInfo = new lazy.ReferrerInfo(
Ci.nsIReferrerInfo.EMPTY,
true,
null
);
}
if (!triggeringPrincipal) {
throw new Error("Must load with a triggering Principal");
}
if (where == "save") {
saveLink(window, url, params);
return;
}
// Establish which window we'll load the link in.
let w;
if (where == "current" && params.targetBrowser) {
w = params.targetBrowser.ownerGlobal;
} else {
w = this.getTargetWindow(window, { forceNonPrivate });
}
// We don't want to open tabs in popups, so try to find a non-popup window in
// that case.
if ((where == "tab" || where == "tabshifted") && w && !w.toolbar.visible) {
w = this.getTargetWindow(window, {
skipPopups: true,
forceNonPrivate,
});
relatedToCurrent = false;
}
updatePrincipals(w, params);
if (!w || where == "window") {
openInWindow(url, params, w || window);
return;
}
// We're now committed to loading the link in an existing browser window.
// Raise the target window before loading the URI, since loading it may
// result in a new frontmost window (e.g. "javascript:window.open('');").
w.focus();
let targetBrowser;
let loadInBackground;
let uriObj;
if (where == "current") {
targetBrowser = params.targetBrowser || w.gBrowser.selectedBrowser;
loadInBackground = false;
try {
uriObj = Services.io.newURI(url);
} catch (e) {}
// In certain tabs, we restrict what if anything may replace the loaded
// page. If a load request bounces off for the currently selected tab,
// we'll open a new tab instead.
let tab = w.gBrowser.getTabForBrowser(targetBrowser);
if (tab == w.FirefoxViewHandler.tab) {
where = "tab";
targetBrowser = null;
} else if (
!allowPinnedTabHostChange &&
tab.pinned &&
url != "about:crashcontent"
) {
try {
// nsIURI.host can throw for non-nsStandardURL nsIURIs.
if (
!uriObj ||
(!uriObj.schemeIs("javascript") &&
targetBrowser.currentURI.host != uriObj.host)
) {
where = "tab";
targetBrowser = null;
}
} catch (err) {
where = "tab";
targetBrowser = null;
}
}
} else {
// `where` is "tab" or "tabshifted", so we'll load the link in a new tab.
loadInBackground = params.inBackground;
if (loadInBackground == null) {
loadInBackground = params.forceForeground
? false
: Services.prefs.getBoolPref("browser.tabs.loadInBackground");
}
}
let focusUrlBar = false;
switch (where) {
case "current":
openInCurrentTab(targetBrowser, url, uriObj, params);
// Don't focus the content area if focus is in the address bar and we're
// loading the New Tab page.
focusUrlBar =
w.document.activeElement == w.gURLBar.inputField &&
w.isBlankPageURL(url);
break;
case "tabshifted":
loadInBackground = !loadInBackground;
// fall through
case "tab": {
focusUrlBar =
!loadInBackground &&
w.isBlankPageURL(url) &&
!lazy.AboutNewTab.willNotifyUser;
let tabUsedForLoad = w.gBrowser.addTab(url, {
referrerInfo: params.referrerInfo,
charset,
postData,
inBackground: loadInBackground,
allowThirdPartyFixup,
relatedToCurrent,
skipAnimation: skipTabAnimation,
userContextId,
originPrincipal,
originStoragePrincipal,
triggeringPrincipal,
allowInheritPrincipal,
triggeringRemoteType,
csp,
forceAllowDataURI,
focusUrlBar,
openerBrowser: params.openerBrowser,
fromExternal: params.fromExternal,
globalHistoryOptions,
schemelessInput: params.schemelessInput,
hasValidUserGestureActivation,
textDirectiveUserActivation,
});
targetBrowser = tabUsedForLoad.linkedBrowser;
resolveOnNewTabCreated?.(targetBrowser);
resolveOnContentBrowserCreated?.(targetBrowser);
if (params.frameID != undefined && w) {
// Only notify it as a WebExtensions' webNavigation.onCreatedNavigationTarget
// event if it contains the expected frameID params.
// (e.g. we should not notify it as a onCreatedNavigationTarget if the user is
// opening a new tab using the keyboard shortcut).
Services.obs.notifyObservers(
{
wrappedJSObject: {
url,
createdTabBrowser: targetBrowser,
sourceTabBrowser: w.gBrowser.selectedBrowser,
sourceFrameID: params.frameID,
},
},
"webNavigation-createdNavigationTarget"
);
}
break;
}
}
if (
!params.avoidBrowserFocus &&
!focusUrlBar &&
targetBrowser == w.gBrowser.selectedBrowser
) {
// Focus the content, but only if the browser used for the load is selected.
targetBrowser.focus();
}
},
/**
* Finds a browser window suitable for opening a link matching the
* requirements given in the `params` argument. If the current window matches
* the requirements then it is returned otherwise the top-most window that
* matches will be returned.
*
* @param {Window} window - The current window.
* @param {Object} params - Parameters for selecting the window.
* @param {boolean} params.skipPopups - Require a non-popup window.
* @param {boolean} params.forceNonPrivate - Require a non-private window.
* @returns {Window | null} A matching browser window or null if none matched.
*/
getTargetWindow(window, { skipPopups, forceNonPrivate } = {}) {
let { top } = window;
// If this is called in a browser window, use that window regardless of
// whether it's the frontmost window, since commands can be executed in
// background windows (bug 626148).
if (
top.document.documentElement.getAttribute("windowtype") ==
"navigator:browser" &&
(!skipPopups || top.toolbar.visible) &&
(!forceNonPrivate || !PrivateBrowsingUtils.isWindowPrivate(top))
) {
return top;
}
return lazy.BrowserWindowTracker.getTopWindow({
private: !forceNonPrivate && PrivateBrowsingUtils.isWindowPrivate(window),
allowPopups: !skipPopups,
});
},
/**
* openUILink handles clicks on UI elements that cause URLs to load.
*
* @param {string} url
* @param {Event | Object} event Event or JSON object representing an Event
* @param {Boolean | Object} aIgnoreButton
* Boolean or object with the same properties as
* accepted by openLinkIn, plus "ignoreButton"
* and "ignoreAlt".
* @param {Boolean} aIgnoreAlt
* @param {Boolean} aAllowThirdPartyFixup
* @param {Object} aPostData
* @param {Object} aReferrerInfo
*/
openUILink(
window,
url,
event,
aIgnoreButton,
aIgnoreAlt,
aAllowThirdPartyFixup,
aPostData,
aReferrerInfo
) {
event = BrowserUtils.getRootEvent(event);
let params;
if (aIgnoreButton && typeof aIgnoreButton == "object") {
params = aIgnoreButton;
// don't forward "ignoreButton" and "ignoreAlt" to openLinkIn
aIgnoreButton = params.ignoreButton;
aIgnoreAlt = params.ignoreAlt;
delete params.ignoreButton;
delete params.ignoreAlt;
} else {
params = {
allowThirdPartyFixup: aAllowThirdPartyFixup,
postData: aPostData,
referrerInfo: aReferrerInfo,
initiatingDoc: event ? event.target.ownerDocument : null,
};
}
if (!params.triggeringPrincipal) {
throw new Error(
"Required argument triggeringPrincipal missing within openUILink"
);
}
let where = BrowserUtils.whereToOpenLink(event, aIgnoreButton, aIgnoreAlt);
params.forceForeground ??= true;
this.openLinkIn(window, url, where, params);
},
/* openTrustedLinkIn will attempt to open the given URI using the SystemPrincipal
* as the trigeringPrincipal, unless a more specific Principal is provided.
*
* Otherwise, parameters are the same as openLinkIn, but we will set `forceForeground`
* to true.
*/
openTrustedLinkIn(window, url, where, params = {}) {
if (!params.triggeringPrincipal) {
params.triggeringPrincipal =
Services.scriptSecurityManager.getSystemPrincipal();
}
params.forceForeground ??= true;
this.openLinkIn(window, url, where, params);
},
/* openWebLinkIn will attempt to open the given URI using the NullPrincipal
* as the triggeringPrincipal, unless a more specific Principal is provided.
*
* Otherwise, parameters are the same as openLinkIn, but we will set `forceForeground`
* to true.
*/
openWebLinkIn(window, url, where, params = {}) {
if (!params.triggeringPrincipal) {
params.triggeringPrincipal =
Services.scriptSecurityManager.createNullPrincipal({});
}
if (params.triggeringPrincipal.isSystemPrincipal) {
throw new Error(
"System principal should never be passed into openWebLinkIn()"
);
}
params.forceForeground ??= true;
this.openLinkIn(window, url, where, params);
},
/**
* Given a URI, guess which container to use to open it. This is used for external
* openers as a quality of life improvement (e.g. to open a document into the container
* where you are logged in to the service that hosts it).
* matches will be returned.
* For now this can only use currently-open tabs, until history is tagged with the
* container id (https://bugzilla.mozilla.org/show_bug.cgi?id=1283320).
*
* @param {nsIURI} aURI - The URI being opened.
* @returns {number | null} The guessed userContextId, or null if none.
*/
guessUserContextId(aURI) {
let host;
try {
host = aURI.host;
} catch (e) {}
if (!host) {
return null;
}
const containerScores = new Map();
let guessedUserContextId = null;
let maxCount = 0;
for (let win of lazy.BrowserWindowTracker.orderedWindows) {
for (let tab of win.gBrowser.visibleTabs) {
let { userContextId } = tab;
let currentURIHost = null;
try {
currentURIHost = tab.linkedBrowser.currentURI.host;
} catch (e) {}
if (currentURIHost == host) {
let count = (containerScores.get(userContextId) ?? 0) + 1;
containerScores.set(userContextId, count);
if (count > maxCount) {
guessedUserContextId = userContextId;
maxCount = count;
}
}
}
}
return guessedUserContextId;
},
};
[ Verzeichnis aufwärts0.53unsichere Verbindung
Übersetzung europäischer Sprachen durch Browser
]
|
2026-03-28
|
|
|
|
|
