7875 lines
269 KiB
JavaScript
7875 lines
269 KiB
JavaScript
/* 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/. */
|
|
|
|
"use strict";
|
|
|
|
const Cc = Components.classes;
|
|
const Ci = Components.interfaces;
|
|
const Cr = Components.results;
|
|
const Cu = Components.utils;
|
|
|
|
this.EXPORTED_SYMBOLS = ["XPIProvider"];
|
|
|
|
Components.utils.import("resource://gre/modules/Services.jsm");
|
|
Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
Components.utils.import("resource://gre/modules/AddonManager.jsm");
|
|
Components.utils.import("resource://gre/modules/Preferences.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository",
|
|
"resource://gre/modules/addons/AddonRepository.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "ChromeManifestParser",
|
|
"resource://gre/modules/ChromeManifestParser.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "LightweightThemeManager",
|
|
"resource://gre/modules/LightweightThemeManager.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
|
|
"resource://gre/modules/FileUtils.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "ZipUtils",
|
|
"resource://gre/modules/ZipUtils.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
|
|
"resource://gre/modules/NetUtil.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "PermissionsUtils",
|
|
"resource://gre/modules/PermissionsUtils.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Promise",
|
|
"resource://gre/modules/Promise.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Task",
|
|
"resource://gre/modules/Task.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "OS",
|
|
"resource://gre/modules/osfile.jsm");
|
|
#ifdef MOZ_DEVTOOLS
|
|
XPCOMUtils.defineLazyModuleGetter(this, "BrowserToolboxProcess",
|
|
"resource://devtools/client/framework/ToolboxProcess.jsm");
|
|
#endif
|
|
XPCOMUtils.defineLazyModuleGetter(this, "ConsoleAPI",
|
|
"resource://gre/modules/Console.jsm");
|
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "Blocklist",
|
|
"@mozilla.org/extensions/blocklist;1",
|
|
Ci.nsIBlocklistService);
|
|
XPCOMUtils.defineLazyServiceGetter(this,
|
|
"ChromeRegistry",
|
|
"@mozilla.org/chrome/chrome-registry;1",
|
|
"nsIChromeRegistry");
|
|
XPCOMUtils.defineLazyServiceGetter(this,
|
|
"ResProtocolHandler",
|
|
"@mozilla.org/network/protocol;1?name=resource",
|
|
"nsIResProtocolHandler");
|
|
XPCOMUtils.defineLazyServiceGetter(this,
|
|
"AddonPathService",
|
|
"@mozilla.org/addon-path-service;1",
|
|
"amIAddonPathService");
|
|
|
|
const nsIFile = Components.Constructor("@mozilla.org/file/local;1", "nsIFile",
|
|
"initWithPath");
|
|
|
|
const PREF_DB_SCHEMA = "extensions.databaseSchema";
|
|
const PREF_INSTALL_CACHE = "extensions.installCache";
|
|
const PREF_XPI_STATE = "extensions.xpiState";
|
|
const PREF_BOOTSTRAP_ADDONS = "extensions.bootstrappedAddons";
|
|
const PREF_PENDING_OPERATIONS = "extensions.pendingOperations";
|
|
const PREF_MATCH_OS_LOCALE = "intl.locale.matchOS";
|
|
const PREF_SELECTED_LOCALE = "general.useragent.locale";
|
|
const PREF_EM_DSS_ENABLED = "extensions.dss.enabled";
|
|
const PREF_DSS_SWITCHPENDING = "extensions.dss.switchPending";
|
|
const PREF_DSS_SKIN_TO_SELECT = "extensions.lastSelectedSkin";
|
|
const PREF_GENERAL_SKINS_SELECTEDSKIN = "general.skins.selectedSkin";
|
|
const PREF_EM_UPDATE_URL = "extensions.update.url";
|
|
const PREF_EM_ENABLED_ADDONS = "extensions.enabledAddons";
|
|
const PREF_EM_EXTENSION_FORMAT = "extensions.";
|
|
const PREF_EM_ENABLED_SCOPES = "extensions.enabledScopes";
|
|
const PREF_EM_AUTO_DISABLED_SCOPES = "extensions.autoDisableScopes";
|
|
const PREF_EM_SHOW_MISMATCH_UI = "extensions.showMismatchUI";
|
|
const PREF_XPI_ENABLED = "xpinstall.enabled";
|
|
const PREF_XPI_WHITELIST_REQUIRED = "xpinstall.whitelist.required";
|
|
const PREF_XPI_DIRECT_WHITELISTED = "xpinstall.whitelist.directRequest";
|
|
const PREF_XPI_FILE_WHITELISTED = "xpinstall.whitelist.fileRequest";
|
|
const PREF_XPI_PERMISSIONS_BRANCH = "xpinstall.";
|
|
const PREF_XPI_UNPACK = "extensions.alwaysUnpack";
|
|
const PREF_INSTALL_REQUIREBUILTINCERTS = "extensions.install.requireBuiltInCerts";
|
|
const PREF_INSTALL_REQUIRESECUREORIGIN = "extensions.install.requireSecureOrigin";
|
|
const PREF_INSTALL_DISTRO_ADDONS = "extensions.installDistroAddons";
|
|
const PREF_BRANCH_INSTALLED_ADDON = "extensions.installedDistroAddon.";
|
|
const PREF_SHOWN_SELECTION_UI = "extensions.shownSelectionUI";
|
|
const PREF_INTERPOSITION_ENABLED = "extensions.interposition.enabled";
|
|
|
|
const PREF_EM_MIN_COMPAT_APP_VERSION = "extensions.minCompatibleAppVersion";
|
|
const PREF_EM_MIN_COMPAT_PLATFORM_VERSION = "extensions.minCompatiblePlatformVersion";
|
|
|
|
const URI_EXTENSION_SELECT_DIALOG = "chrome://mozapps/content/extensions/selectAddons.xul";
|
|
const URI_EXTENSION_UPDATE_DIALOG = "chrome://mozapps/content/extensions/update.xul";
|
|
const URI_EXTENSION_STRINGS = "chrome://mozapps/locale/extensions/extensions.properties";
|
|
|
|
const STRING_TYPE_NAME = "type.%ID%.name";
|
|
|
|
const DIR_EXTENSIONS = "extensions";
|
|
const DIR_STAGE = "staged";
|
|
const DIR_XPI_STAGE = "staged-xpis";
|
|
const DIR_TRASH = "trash";
|
|
|
|
const FILE_DATABASE = "extensions.json";
|
|
const FILE_OLD_CACHE = "extensions.cache";
|
|
const FILE_INSTALL_MANIFEST = "install.rdf";
|
|
#ifndef MOZ_JETPACK
|
|
const FILE_JETPACK_MANIFEST_1 = "harness-options.json";
|
|
const FILE_JETPACK_MANIFEST_2 = "package.json";
|
|
#endif
|
|
const FILE_WEBEXT_MANIFEST = "manifest.json";
|
|
const FILE_XPI_ADDONS_LIST = "extensions.ini";
|
|
|
|
const KEY_PROFILEDIR = "ProfD";
|
|
const KEY_APPDIR = "XCurProcD";
|
|
const KEY_TEMPDIR = "TmpD";
|
|
const KEY_APP_DISTRIBUTION = "XREAppDist";
|
|
|
|
const KEY_APP_PROFILE = "app-profile";
|
|
const KEY_APP_GLOBAL = "app-global";
|
|
const KEY_APP_SYSTEM_LOCAL = "app-system-local";
|
|
const KEY_APP_SYSTEM_SHARE = "app-system-share";
|
|
const KEY_APP_SYSTEM_USER = "app-system-user";
|
|
|
|
const NOTIFICATION_FLUSH_PERMISSIONS = "flush-pending-permissions";
|
|
const XPI_PERMISSION = "install";
|
|
|
|
const RDFURI_INSTALL_MANIFEST_ROOT = "urn:mozilla:install-manifest";
|
|
const PREFIX_NS_EM = "http://www.mozilla.org/2004/em-rdf#";
|
|
|
|
const TOOLKIT_ID = "toolkit@mozilla.org";
|
|
#ifdef MOZ_PHOENIX_EXTENSIONS
|
|
const FIREFOX_ID = "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}"
|
|
const FIREFOX_APPCOMPATVERSION = "56.9"
|
|
#endif
|
|
|
|
// The value for this is in Makefile.in
|
|
#expand const DB_SCHEMA = __MOZ_EXTENSIONS_DB_SCHEMA__;
|
|
XPCOMUtils.defineConstant(this, "DB_SCHEMA", DB_SCHEMA);
|
|
#ifdef MOZ_DEVTOOLS
|
|
const NOTIFICATION_TOOLBOXPROCESS_LOADED = "ToolboxProcessLoaded";
|
|
#endif
|
|
|
|
// Properties that exist in the install manifest
|
|
const PROP_METADATA = ["id", "version", "type", "internalName", "updateURL",
|
|
"updateKey", "optionsURL", "optionsType", "aboutURL",
|
|
"iconURL", "icon64URL"];
|
|
const PROP_LOCALE_SINGLE = ["name", "description", "creator", "homepageURL"];
|
|
const PROP_LOCALE_MULTI = ["developers", "translators", "contributors"];
|
|
const PROP_TARGETAPP = ["id", "minVersion", "maxVersion"];
|
|
|
|
// Properties that should be migrated where possible from an old database. These
|
|
// shouldn't include properties that can be read directly from install.rdf files
|
|
// or calculated
|
|
const DB_MIGRATE_METADATA= ["installDate", "userDisabled", "softDisabled",
|
|
"sourceURI", "applyBackgroundUpdates",
|
|
"releaseNotesURI", "foreignInstall", "syncGUID"];
|
|
// Properties to cache and reload when an addon installation is pending
|
|
const PENDING_INSTALL_METADATA =
|
|
["syncGUID", "targetApplications", "userDisabled", "softDisabled",
|
|
"existingAddonID", "sourceURI", "releaseNotesURI", "installDate",
|
|
"updateDate", "applyBackgroundUpdates", "compatibilityOverrides"];
|
|
|
|
// Note: When adding/changing/removing items here, remember to change the
|
|
// DB schema version to ensure changes are picked up ASAP.
|
|
const STATIC_BLOCKLIST_PATTERNS = [
|
|
{ creator: "Mozilla Corp.",
|
|
level: Blocklist.STATE_BLOCKED,
|
|
blockID: "i162" },
|
|
{ creator: "Mozilla.org",
|
|
level: Blocklist.STATE_BLOCKED,
|
|
blockID: "i162" }
|
|
];
|
|
|
|
|
|
const BOOTSTRAP_REASONS = {
|
|
APP_STARTUP : 1,
|
|
APP_SHUTDOWN : 2,
|
|
ADDON_ENABLE : 3,
|
|
ADDON_DISABLE : 4,
|
|
ADDON_INSTALL : 5,
|
|
ADDON_UNINSTALL : 6,
|
|
ADDON_UPGRADE : 7,
|
|
ADDON_DOWNGRADE : 8
|
|
};
|
|
|
|
// Map new string type identifiers to old style nsIUpdateItem types
|
|
const TYPES = {
|
|
extension: 2,
|
|
theme: 4,
|
|
locale: 8,
|
|
multipackage: 32,
|
|
dictionary: 64,
|
|
experiment: 128,
|
|
};
|
|
|
|
const RESTARTLESS_TYPES = new Set([
|
|
"dictionary",
|
|
"experiment",
|
|
"locale",
|
|
]);
|
|
|
|
// Keep track of where we are in startup for telemetry
|
|
// event happened during XPIDatabase.startup()
|
|
const XPI_STARTING = "XPIStarting";
|
|
// event happened after startup() but before the final-ui-startup event
|
|
const XPI_BEFORE_UI_STARTUP = "BeforeFinalUIStartup";
|
|
// event happened after final-ui-startup
|
|
const XPI_AFTER_UI_STARTUP = "AfterFinalUIStartup";
|
|
|
|
const COMPATIBLE_BY_DEFAULT_TYPES = {
|
|
extension: true,
|
|
dictionary: true
|
|
};
|
|
|
|
const MSG_JAR_FLUSH = "AddonJarFlush";
|
|
const MSG_MESSAGE_MANAGER_CACHES_FLUSH = "AddonMessageManagerCachesFlush";
|
|
|
|
var gGlobalScope = this;
|
|
|
|
/**
|
|
* Valid IDs fit this pattern.
|
|
*/
|
|
var gIDTest = /^(\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}|[a-z0-9-\._]*\@[a-z0-9-\._]+)$/i;
|
|
|
|
Cu.import("resource://gre/modules/Log.jsm");
|
|
const LOGGER_ID = "addons.xpi";
|
|
|
|
// Create a new logger for use by all objects in this Addons XPI Provider module
|
|
// (Requires AddonManager.jsm)
|
|
var logger = Log.repository.getLogger(LOGGER_ID);
|
|
|
|
const LAZY_OBJECTS = ["XPIDatabase"];
|
|
|
|
var gLazyObjectsLoaded = false;
|
|
|
|
function loadLazyObjects() {
|
|
let scope = {};
|
|
scope.AddonInternal = AddonInternal;
|
|
scope.XPIProvider = XPIProvider;
|
|
scope.XPIStates = XPIStates;
|
|
Services.scriptloader.loadSubScript("resource://gre/modules/addons/XPIProviderUtils.js",
|
|
scope);
|
|
|
|
for (let name of LAZY_OBJECTS) {
|
|
delete gGlobalScope[name];
|
|
gGlobalScope[name] = scope[name];
|
|
}
|
|
gLazyObjectsLoaded = true;
|
|
return scope;
|
|
}
|
|
|
|
for (let name of LAZY_OBJECTS) {
|
|
Object.defineProperty(gGlobalScope, name, {
|
|
get: function lazyObjectGetter() {
|
|
let objs = loadLazyObjects();
|
|
return objs[name];
|
|
},
|
|
configurable: true
|
|
});
|
|
}
|
|
|
|
|
|
function findMatchingStaticBlocklistItem(aAddon) {
|
|
for (let item of STATIC_BLOCKLIST_PATTERNS) {
|
|
if ("creator" in item && typeof item.creator == "string") {
|
|
if ((aAddon.defaultLocale && aAddon.defaultLocale.creator == item.creator) ||
|
|
(aAddon.selectedLocale && aAddon.selectedLocale.creator == item.creator)) {
|
|
return item;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets permissions on a file
|
|
*
|
|
* @param aFile
|
|
* The file or directory to operate on.
|
|
* @param aPermissions
|
|
* The permisions to set
|
|
*/
|
|
function setFilePermissions(aFile, aPermissions) {
|
|
try {
|
|
aFile.permissions = aPermissions;
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to set permissions " + aPermissions.toString(8) + " on " +
|
|
aFile.path, e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A safe way to install a file or the contents of a directory to a new
|
|
* directory. The file or directory is moved or copied recursively and if
|
|
* anything fails an attempt is made to rollback the entire operation. The
|
|
* operation may also be rolled back to its original state after it has
|
|
* completed by calling the rollback method.
|
|
*
|
|
* Operations can be chained. Calling move or copy multiple times will remember
|
|
* the whole set and if one fails all of the operations will be rolled back.
|
|
*/
|
|
function SafeInstallOperation() {
|
|
this._installedFiles = [];
|
|
this._createdDirs = [];
|
|
}
|
|
|
|
SafeInstallOperation.prototype = {
|
|
_installedFiles: null,
|
|
_createdDirs: null,
|
|
|
|
_installFile: function SIO_installFile(aFile, aTargetDirectory, aCopy) {
|
|
let oldFile = aCopy ? null : aFile.clone();
|
|
let newFile = aFile.clone();
|
|
try {
|
|
if (aCopy)
|
|
newFile.copyTo(aTargetDirectory, null);
|
|
else
|
|
newFile.moveTo(aTargetDirectory, null);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to " + (aCopy ? "copy" : "move") + " file " + aFile.path +
|
|
" to " + aTargetDirectory.path, e);
|
|
throw e;
|
|
}
|
|
this._installedFiles.push({ oldFile: oldFile, newFile: newFile });
|
|
},
|
|
|
|
_installDirectory: function SIO_installDirectory(aDirectory, aTargetDirectory, aCopy) {
|
|
let newDir = aTargetDirectory.clone();
|
|
newDir.append(aDirectory.leafName);
|
|
try {
|
|
newDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to create directory " + newDir.path, e);
|
|
throw e;
|
|
}
|
|
this._createdDirs.push(newDir);
|
|
|
|
// Use a snapshot of the directory contents to avoid possible issues with
|
|
// iterating over a directory while removing files from it (the YAFFS2
|
|
// embedded filesystem has this issue, see bug 772238), and to remove
|
|
// normal files before their resource forks on OSX (see bug 733436).
|
|
let entries = getDirectoryEntries(aDirectory, true);
|
|
entries.forEach(function(aEntry) {
|
|
try {
|
|
this._installDirEntry(aEntry, newDir, aCopy);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to " + (aCopy ? "copy" : "move") + " entry " +
|
|
aEntry.path, e);
|
|
throw e;
|
|
}
|
|
}, this);
|
|
|
|
// If this is only a copy operation then there is nothing else to do
|
|
if (aCopy)
|
|
return;
|
|
|
|
// The directory should be empty by this point. If it isn't this will throw
|
|
// and all of the operations will be rolled back
|
|
try {
|
|
setFilePermissions(aDirectory, FileUtils.PERMS_DIRECTORY);
|
|
aDirectory.remove(false);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to remove directory " + aDirectory.path, e);
|
|
throw e;
|
|
}
|
|
|
|
// Note we put the directory move in after all the file moves so the
|
|
// directory is recreated before all the files are moved back
|
|
this._installedFiles.push({ oldFile: aDirectory, newFile: newDir });
|
|
},
|
|
|
|
_installDirEntry: function SIO_installDirEntry(aDirEntry, aTargetDirectory, aCopy) {
|
|
let isDir = null;
|
|
|
|
try {
|
|
isDir = aDirEntry.isDirectory();
|
|
}
|
|
catch (e) {
|
|
// If the file has already gone away then don't worry about it, this can
|
|
// happen on OSX where the resource fork is automatically moved with the
|
|
// data fork for the file. See bug 733436.
|
|
if (e.result == Cr.NS_ERROR_FILE_TARGET_DOES_NOT_EXIST)
|
|
return;
|
|
|
|
logger.error("Failure " + (aCopy ? "copying" : "moving") + " " + aDirEntry.path +
|
|
" to " + aTargetDirectory.path);
|
|
throw e;
|
|
}
|
|
|
|
try {
|
|
if (isDir)
|
|
this._installDirectory(aDirEntry, aTargetDirectory, aCopy);
|
|
else
|
|
this._installFile(aDirEntry, aTargetDirectory, aCopy);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failure " + (aCopy ? "copying" : "moving") + " " + aDirEntry.path +
|
|
" to " + aTargetDirectory.path);
|
|
throw e;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Moves a file or directory into a new directory. If an error occurs then all
|
|
* files that have been moved will be moved back to their original location.
|
|
*
|
|
* @param aFile
|
|
* The file or directory to be moved.
|
|
* @param aTargetDirectory
|
|
* The directory to move into, this is expected to be an empty
|
|
* directory.
|
|
*/
|
|
moveUnder: function SIO_move(aFile, aTargetDirectory) {
|
|
try {
|
|
this._installDirEntry(aFile, aTargetDirectory, false);
|
|
}
|
|
catch (e) {
|
|
this.rollback();
|
|
throw e;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Renames a file to a new location. If an error occurs then all
|
|
* files that have been moved will be moved back to their original location.
|
|
*
|
|
* @param aOldLocation
|
|
* The old location of the file.
|
|
* @param aNewLocation
|
|
* The new location of the file.
|
|
*/
|
|
moveTo: function(aOldLocation, aNewLocation) {
|
|
try {
|
|
let oldFile = aOldLocation.clone(), newFile = aNewLocation.clone();
|
|
oldFile.moveTo(newFile.parent, newFile.leafName);
|
|
this._installedFiles.push({ oldFile: oldFile, newFile: newFile, isMoveTo: true});
|
|
}
|
|
catch(e) {
|
|
this.rollback();
|
|
throw e;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Copies a file or directory into a new directory. If an error occurs then
|
|
* all new files that have been created will be removed.
|
|
*
|
|
* @param aFile
|
|
* The file or directory to be copied.
|
|
* @param aTargetDirectory
|
|
* The directory to copy into, this is expected to be an empty
|
|
* directory.
|
|
*/
|
|
copy: function SIO_copy(aFile, aTargetDirectory) {
|
|
try {
|
|
this._installDirEntry(aFile, aTargetDirectory, true);
|
|
}
|
|
catch (e) {
|
|
this.rollback();
|
|
throw e;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Rolls back all the moves that this operation performed. If an exception
|
|
* occurs here then both old and new directories are left in an indeterminate
|
|
* state
|
|
*/
|
|
rollback: function SIO_rollback() {
|
|
while (this._installedFiles.length > 0) {
|
|
let move = this._installedFiles.pop();
|
|
if (move.isMoveTo) {
|
|
move.newFile.moveTo(oldDir.parent, oldDir.leafName);
|
|
}
|
|
else if (move.newFile.isDirectory()) {
|
|
let oldDir = move.oldFile.parent.clone();
|
|
oldDir.append(move.oldFile.leafName);
|
|
oldDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
|
|
}
|
|
else if (!move.oldFile) {
|
|
// No old file means this was a copied file
|
|
move.newFile.remove(true);
|
|
}
|
|
else {
|
|
move.newFile.moveTo(move.oldFile.parent, null);
|
|
}
|
|
}
|
|
|
|
while (this._createdDirs.length > 0)
|
|
recursiveRemove(this._createdDirs.pop());
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Gets the currently selected locale for display.
|
|
* @return the selected locale or "en-US" if none is selected
|
|
*/
|
|
function getLocale() {
|
|
if (Preferences.get(PREF_MATCH_OS_LOCALE, false))
|
|
return Services.locale.getLocaleComponentForUserAgent();
|
|
try {
|
|
let locale = Preferences.get(PREF_SELECTED_LOCALE, null, Ci.nsIPrefLocalizedString);
|
|
if (locale)
|
|
return locale;
|
|
}
|
|
catch (e) {}
|
|
return Preferences.get(PREF_SELECTED_LOCALE, "en-US");
|
|
}
|
|
|
|
/**
|
|
* Selects the closest matching locale from a list of locales.
|
|
*
|
|
* @param aLocales
|
|
* An array of locales
|
|
* @return the best match for the currently selected locale
|
|
*/
|
|
function findClosestLocale(aLocales) {
|
|
let appLocale = getLocale();
|
|
|
|
// Holds the best matching localized resource
|
|
var bestmatch = null;
|
|
// The number of locale parts it matched with
|
|
var bestmatchcount = 0;
|
|
// The number of locale parts in the match
|
|
var bestpartcount = 0;
|
|
|
|
var matchLocales = [appLocale.toLowerCase()];
|
|
/* If the current locale is English then it will find a match if there is
|
|
a valid match for en-US so no point searching that locale too. */
|
|
if (matchLocales[0].substring(0, 3) != "en-")
|
|
matchLocales.push("en-us");
|
|
|
|
for each (var locale in matchLocales) {
|
|
var lparts = locale.split("-");
|
|
for each (var localized in aLocales) {
|
|
for each (let found in localized.locales) {
|
|
found = found.toLowerCase();
|
|
// Exact match is returned immediately
|
|
if (locale == found)
|
|
return localized;
|
|
|
|
var fparts = found.split("-");
|
|
/* If we have found a possible match and this one isn't any longer
|
|
then we dont need to check further. */
|
|
if (bestmatch && fparts.length < bestmatchcount)
|
|
continue;
|
|
|
|
// Count the number of parts that match
|
|
var maxmatchcount = Math.min(fparts.length, lparts.length);
|
|
var matchcount = 0;
|
|
while (matchcount < maxmatchcount &&
|
|
fparts[matchcount] == lparts[matchcount])
|
|
matchcount++;
|
|
|
|
/* If we matched more than the last best match or matched the same and
|
|
this locale is less specific than the last best match. */
|
|
if (matchcount > bestmatchcount ||
|
|
(matchcount == bestmatchcount && fparts.length < bestpartcount)) {
|
|
bestmatch = localized;
|
|
bestmatchcount = matchcount;
|
|
bestpartcount = fparts.length;
|
|
}
|
|
}
|
|
}
|
|
// If we found a valid match for this locale return it
|
|
if (bestmatch)
|
|
return bestmatch;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Sets the userDisabled and softDisabled properties of an add-on based on what
|
|
* values those properties had for a previous instance of the add-on. The
|
|
* previous instance may be a previous install or in the case of an application
|
|
* version change the same add-on.
|
|
*
|
|
* NOTE: this may modify aNewAddon in place; callers should save the database if
|
|
* necessary
|
|
*
|
|
* @param aOldAddon
|
|
* The previous instance of the add-on
|
|
* @param aNewAddon
|
|
* The new instance of the add-on
|
|
* @param aAppVersion
|
|
* The optional application version to use when checking the blocklist
|
|
* or undefined to use the current application
|
|
* @param aPlatformVersion
|
|
* The optional platform version to use when checking the blocklist or
|
|
* undefined to use the current platform
|
|
*/
|
|
function applyBlocklistChanges(aOldAddon, aNewAddon, aOldAppVersion,
|
|
aOldPlatformVersion) {
|
|
// Copy the properties by default
|
|
aNewAddon.userDisabled = aOldAddon.userDisabled;
|
|
aNewAddon.softDisabled = aOldAddon.softDisabled;
|
|
|
|
let oldBlocklistState = Blocklist.getAddonBlocklistState(createWrapper(aOldAddon),
|
|
aOldAppVersion,
|
|
aOldPlatformVersion);
|
|
let newBlocklistState = Blocklist.getAddonBlocklistState(createWrapper(aNewAddon));
|
|
|
|
// If the blocklist state hasn't changed then the properties don't need to
|
|
// change
|
|
if (newBlocklistState == oldBlocklistState)
|
|
return;
|
|
|
|
if (newBlocklistState == Blocklist.STATE_SOFTBLOCKED) {
|
|
if (aNewAddon.type != "theme") {
|
|
// The add-on has become softblocked, set softDisabled if it isn't already
|
|
// userDisabled
|
|
aNewAddon.softDisabled = !aNewAddon.userDisabled;
|
|
}
|
|
else {
|
|
// Themes just get userDisabled to switch back to the default theme
|
|
aNewAddon.userDisabled = true;
|
|
}
|
|
}
|
|
else {
|
|
// If the new add-on is not softblocked then it cannot be softDisabled
|
|
aNewAddon.softDisabled = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates whether an add-on should be appDisabled or not.
|
|
*
|
|
* @param aAddon
|
|
* The add-on to check
|
|
* @return true if the add-on should not be appDisabled
|
|
*/
|
|
function isUsableAddon(aAddon) {
|
|
// Hack to ensure the default theme is always usable
|
|
if (aAddon.type == "theme" && aAddon.internalName == XPIProvider.defaultSkin)
|
|
return true;
|
|
|
|
if (aAddon.blocklistState == Blocklist.STATE_BLOCKED)
|
|
return false;
|
|
|
|
if (AddonManager.checkUpdateSecurity && !aAddon.providesUpdatesSecurely)
|
|
return false;
|
|
|
|
if (!aAddon.isPlatformCompatible)
|
|
return false;
|
|
|
|
if (AddonManager.checkCompatibility) {
|
|
if (!aAddon.isCompatible)
|
|
return false;
|
|
}
|
|
else {
|
|
if (!aAddon.matchingTargetApplication)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "gRDF", "@mozilla.org/rdf/rdf-service;1",
|
|
Ci.nsIRDFService);
|
|
|
|
function EM_R(aProperty) {
|
|
return gRDF.GetResource(PREFIX_NS_EM + aProperty);
|
|
}
|
|
|
|
function createAddonDetails(id, aAddon) {
|
|
return {
|
|
id: id || aAddon.id,
|
|
type: aAddon.type,
|
|
version: aAddon.version
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Converts an RDF literal, resource or integer into a string.
|
|
*
|
|
* @param aLiteral
|
|
* The RDF object to convert
|
|
* @return a string if the object could be converted or null
|
|
*/
|
|
function getRDFValue(aLiteral) {
|
|
if (aLiteral instanceof Ci.nsIRDFLiteral)
|
|
return aLiteral.Value;
|
|
if (aLiteral instanceof Ci.nsIRDFResource)
|
|
return aLiteral.Value;
|
|
if (aLiteral instanceof Ci.nsIRDFInt)
|
|
return aLiteral.Value;
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets an RDF property as a string
|
|
*
|
|
* @param aDs
|
|
* The RDF datasource to read the property from
|
|
* @param aResource
|
|
* The RDF resource to read the property from
|
|
* @param aProperty
|
|
* The property to read
|
|
* @return a string if the property existed or null
|
|
*/
|
|
function getRDFProperty(aDs, aResource, aProperty) {
|
|
return getRDFValue(aDs.GetTarget(aResource, EM_R(aProperty), true));
|
|
}
|
|
|
|
/**
|
|
* Reads an AddonInternal object from an RDF stream.
|
|
*
|
|
* @param aUri
|
|
* The URI that the manifest is being read from
|
|
* @param aStream
|
|
* An open stream to read the RDF from
|
|
* @return an AddonInternal object
|
|
* @throws if the install manifest in the RDF stream is corrupt or could not
|
|
* be read
|
|
*/
|
|
function loadManifestFromRDF(aUri, aStream) {
|
|
function getPropertyArray(aDs, aSource, aProperty) {
|
|
let values = [];
|
|
let targets = aDs.GetTargets(aSource, EM_R(aProperty), true);
|
|
while (targets.hasMoreElements())
|
|
values.push(getRDFValue(targets.getNext()));
|
|
|
|
return values;
|
|
}
|
|
|
|
/**
|
|
* Reads locale properties from either the main install manifest root or
|
|
* an em:localized section in the install manifest.
|
|
*
|
|
* @param aDs
|
|
* The nsIRDFDatasource to read from
|
|
* @param aSource
|
|
* The nsIRDFResource to read the properties from
|
|
* @param isDefault
|
|
* True if the locale is to be read from the main install manifest
|
|
* root
|
|
* @param aSeenLocales
|
|
* An array of locale names already seen for this install manifest.
|
|
* Any locale names seen as a part of this function will be added to
|
|
* this array
|
|
* @return an object containing the locale properties
|
|
*/
|
|
function readLocale(aDs, aSource, isDefault, aSeenLocales) {
|
|
let locale = { };
|
|
if (!isDefault) {
|
|
locale.locales = [];
|
|
let targets = ds.GetTargets(aSource, EM_R("locale"), true);
|
|
while (targets.hasMoreElements()) {
|
|
let localeName = getRDFValue(targets.getNext());
|
|
if (!localeName) {
|
|
logger.warn("Ignoring empty locale in localized properties");
|
|
continue;
|
|
}
|
|
if (aSeenLocales.indexOf(localeName) != -1) {
|
|
logger.warn("Ignoring duplicate locale in localized properties");
|
|
continue;
|
|
}
|
|
aSeenLocales.push(localeName);
|
|
locale.locales.push(localeName);
|
|
}
|
|
|
|
if (locale.locales.length == 0) {
|
|
logger.warn("Ignoring localized properties with no listed locales");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
PROP_LOCALE_SINGLE.forEach(function(aProp) {
|
|
locale[aProp] = getRDFProperty(aDs, aSource, aProp);
|
|
});
|
|
|
|
PROP_LOCALE_MULTI.forEach(function(aProp) {
|
|
// Don't store empty arrays
|
|
let props = getPropertyArray(aDs, aSource,
|
|
aProp.substring(0, aProp.length - 1));
|
|
if (props.length > 0)
|
|
locale[aProp] = props;
|
|
});
|
|
|
|
return locale;
|
|
}
|
|
|
|
let rdfParser = Cc["@mozilla.org/rdf/xml-parser;1"].
|
|
createInstance(Ci.nsIRDFXMLParser)
|
|
let ds = Cc["@mozilla.org/rdf/datasource;1?name=in-memory-datasource"].
|
|
createInstance(Ci.nsIRDFDataSource);
|
|
let listener = rdfParser.parseAsync(ds, aUri);
|
|
let channel = Cc["@mozilla.org/network/input-stream-channel;1"].
|
|
createInstance(Ci.nsIInputStreamChannel);
|
|
channel.setURI(aUri);
|
|
channel.contentStream = aStream;
|
|
channel.QueryInterface(Ci.nsIChannel);
|
|
channel.contentType = "text/xml";
|
|
|
|
listener.onStartRequest(channel, null);
|
|
|
|
try {
|
|
let pos = 0;
|
|
let count = aStream.available();
|
|
while (count > 0) {
|
|
listener.onDataAvailable(channel, null, aStream, pos, count);
|
|
pos += count;
|
|
count = aStream.available();
|
|
}
|
|
listener.onStopRequest(channel, null, Components.results.NS_OK);
|
|
}
|
|
catch (e) {
|
|
listener.onStopRequest(channel, null, e.result);
|
|
throw e;
|
|
}
|
|
|
|
let root = gRDF.GetResource(RDFURI_INSTALL_MANIFEST_ROOT);
|
|
let addon = new AddonInternal();
|
|
PROP_METADATA.forEach(function(aProp) {
|
|
addon[aProp] = getRDFProperty(ds, root, aProp);
|
|
});
|
|
addon.unpack = getRDFProperty(ds, root, "unpack") == "true";
|
|
|
|
if (!addon.type) {
|
|
addon.type = addon.internalName ? "theme" : "extension";
|
|
}
|
|
else {
|
|
let type = addon.type;
|
|
addon.type = null;
|
|
for (let name in TYPES) {
|
|
if (TYPES[name] == type) {
|
|
addon.type = name;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!(addon.type in TYPES))
|
|
throw new Error("Install manifest specifies unknown type: " + addon.type);
|
|
|
|
if (addon.type != "multipackage") {
|
|
if (!addon.id)
|
|
throw new Error("No ID in install manifest");
|
|
if (!gIDTest.test(addon.id))
|
|
throw new Error("Illegal add-on ID " + addon.id);
|
|
if (!addon.version)
|
|
throw new Error("No version in install manifest");
|
|
}
|
|
|
|
addon.strictCompatibility = !(addon.type in COMPATIBLE_BY_DEFAULT_TYPES) ||
|
|
getRDFProperty(ds, root, "strictCompatibility") == "true";
|
|
|
|
// Only read these properties for extensions.
|
|
if (addon.type == "extension") {
|
|
addon.bootstrap = getRDFProperty(ds, root, "bootstrap") == "true";
|
|
addon.multiprocessCompatible = getRDFProperty(ds, root, "multiprocessCompatible") == "true";
|
|
if (addon.optionsType &&
|
|
addon.optionsType != AddonManager.OPTIONS_TYPE_DIALOG &&
|
|
addon.optionsType != AddonManager.OPTIONS_TYPE_INLINE &&
|
|
addon.optionsType != AddonManager.OPTIONS_TYPE_TAB &&
|
|
addon.optionsType != AddonManager.OPTIONS_TYPE_INLINE_INFO) {
|
|
throw new Error("Install manifest specifies unknown type: " + addon.optionsType);
|
|
}
|
|
}
|
|
else {
|
|
// Some add-on types are always restartless.
|
|
if (RESTARTLESS_TYPES.has(addon.type)) {
|
|
addon.bootstrap = true;
|
|
}
|
|
|
|
// Only extensions are allowed to provide an optionsURL, optionsType or aboutURL. For
|
|
// all other types they are silently ignored
|
|
addon.optionsURL = null;
|
|
addon.optionsType = null;
|
|
addon.aboutURL = null;
|
|
|
|
if (addon.type == "theme") {
|
|
if (!addon.internalName)
|
|
throw new Error("Themes must include an internalName property");
|
|
addon.skinnable = getRDFProperty(ds, root, "skinnable") == "true";
|
|
}
|
|
}
|
|
|
|
addon.defaultLocale = readLocale(ds, root, true);
|
|
|
|
let seenLocales = [];
|
|
addon.locales = [];
|
|
let targets = ds.GetTargets(root, EM_R("localized"), true);
|
|
while (targets.hasMoreElements()) {
|
|
let target = targets.getNext().QueryInterface(Ci.nsIRDFResource);
|
|
let locale = readLocale(ds, target, false, seenLocales);
|
|
if (locale)
|
|
addon.locales.push(locale);
|
|
}
|
|
|
|
let seenApplications = [];
|
|
addon.targetApplications = [];
|
|
targets = ds.GetTargets(root, EM_R("targetApplication"), true);
|
|
while (targets.hasMoreElements()) {
|
|
let target = targets.getNext().QueryInterface(Ci.nsIRDFResource);
|
|
let targetAppInfo = {};
|
|
PROP_TARGETAPP.forEach(function(aProp) {
|
|
targetAppInfo[aProp] = getRDFProperty(ds, target, aProp);
|
|
});
|
|
if (!targetAppInfo.id || !targetAppInfo.minVersion ||
|
|
!targetAppInfo.maxVersion) {
|
|
logger.warn("Ignoring invalid targetApplication entry in install manifest");
|
|
continue;
|
|
}
|
|
if (seenApplications.indexOf(targetAppInfo.id) != -1) {
|
|
logger.warn("Ignoring duplicate targetApplication entry for " + targetAppInfo.id +
|
|
" in install manifest");
|
|
continue;
|
|
}
|
|
seenApplications.push(targetAppInfo.id);
|
|
addon.targetApplications.push(targetAppInfo);
|
|
}
|
|
|
|
// Note that we don't need to check for duplicate targetPlatform entries since
|
|
// the RDF service coalesces them for us.
|
|
let targetPlatforms = getPropertyArray(ds, root, "targetPlatform");
|
|
addon.targetPlatforms = [];
|
|
targetPlatforms.forEach(function(aPlatform) {
|
|
let platform = {
|
|
os: null,
|
|
abi: null
|
|
};
|
|
|
|
let pos = aPlatform.indexOf("_");
|
|
if (pos != -1) {
|
|
platform.os = aPlatform.substring(0, pos);
|
|
platform.abi = aPlatform.substring(pos + 1);
|
|
}
|
|
else {
|
|
platform.os = aPlatform;
|
|
}
|
|
|
|
addon.targetPlatforms.push(platform);
|
|
});
|
|
|
|
// A theme's userDisabled value is true if the theme is not the selected skin
|
|
// or if there is an active lightweight theme. We ignore whether softblocking
|
|
// is in effect since it would change the active theme.
|
|
if (addon.type == "theme") {
|
|
addon.userDisabled = !!LightweightThemeManager.currentTheme ||
|
|
addon.internalName != XPIProvider.selectedSkin;
|
|
}
|
|
// Experiments are disabled by default. It is up to the Experiments Manager
|
|
// to enable them (it drives installation).
|
|
else if (addon.type == "experiment") {
|
|
addon.userDisabled = true;
|
|
}
|
|
else {
|
|
addon.userDisabled = false;
|
|
addon.softDisabled = addon.blocklistState == Blocklist.STATE_SOFTBLOCKED;
|
|
}
|
|
|
|
addon.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DEFAULT;
|
|
|
|
// Experiments are managed and updated through an external "experiments
|
|
// manager." So disable some built-in mechanisms.
|
|
if (addon.type == "experiment") {
|
|
addon.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DISABLE;
|
|
addon.updateURL = null;
|
|
addon.updateKey = null;
|
|
|
|
addon.targetApplications = [];
|
|
addon.targetPlatforms = [];
|
|
}
|
|
|
|
// Load the storage service before NSS (nsIRandomGenerator),
|
|
// to avoid a SQLite initialization error (bug 717904).
|
|
let storage = Services.storage;
|
|
|
|
// Generate random GUID used for Sync.
|
|
// This was lifted from util.js:makeGUID() from services-sync.
|
|
let guid = Cc["@mozilla.org/uuid-generator;1"]
|
|
.getService(Ci.nsIUUIDGenerator)
|
|
.generateUUID().toString();
|
|
addon.syncGUID = guid;
|
|
|
|
return addon;
|
|
}
|
|
|
|
/**
|
|
* Loads an AddonInternal object from an add-on extracted in a directory.
|
|
*
|
|
* @param aDir
|
|
* The nsIFile directory holding the add-on
|
|
* @return an AddonInternal object
|
|
* @throws if the directory does not contain a valid install manifest
|
|
*/
|
|
function loadManifestFromDir(aDir) {
|
|
function getFileSize(aFile) {
|
|
if (aFile.isSymlink())
|
|
return 0;
|
|
|
|
if (!aFile.isDirectory())
|
|
return aFile.fileSize;
|
|
|
|
let size = 0;
|
|
let entries = aFile.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
|
|
let entry;
|
|
while ((entry = entries.nextFile))
|
|
size += getFileSize(entry);
|
|
entries.close();
|
|
return size;
|
|
}
|
|
|
|
let file = aDir.clone();
|
|
file.append(FILE_INSTALL_MANIFEST);
|
|
if (!file.exists() || !file.isFile())
|
|
throw new Error("Directory " + aDir.path + " does not contain a valid " +
|
|
"install manifest");
|
|
|
|
let fis = Cc["@mozilla.org/network/file-input-stream;1"].
|
|
createInstance(Ci.nsIFileInputStream);
|
|
fis.init(file, -1, -1, false);
|
|
let bis = Cc["@mozilla.org/network/buffered-input-stream;1"].
|
|
createInstance(Ci.nsIBufferedInputStream);
|
|
bis.init(fis, 4096);
|
|
|
|
try {
|
|
let addon = loadManifestFromRDF(Services.io.newFileURI(file), bis);
|
|
addon._sourceBundle = aDir.clone();
|
|
addon.size = getFileSize(aDir);
|
|
|
|
file = aDir.clone();
|
|
file.append("chrome.manifest");
|
|
let chromeManifest = ChromeManifestParser.parseSync(Services.io.newFileURI(file));
|
|
addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest,
|
|
"binary-component");
|
|
|
|
addon.appDisabled = !isUsableAddon(addon);
|
|
return addon;
|
|
}
|
|
finally {
|
|
bis.close();
|
|
fis.close();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads an AddonInternal object from an nsIZipReader for an add-on.
|
|
*
|
|
* @param aZipReader
|
|
* An open nsIZipReader for the add-on's files
|
|
* @return an AddonInternal object
|
|
* @throws if the XPI file does not contain a valid install manifest.
|
|
* Throws with |webext:true| if a WebExtension manifest was found
|
|
* to distinguish between WebExtensions and corrupt files.
|
|
* Throws with |jetpacksdk:true| if a Jetpack files were found
|
|
* if Jetpack its self isn't built.
|
|
*/
|
|
function loadManifestFromZipReader(aZipReader) {
|
|
// If WebExtension but not install.rdf throw an error
|
|
if (aZipReader.hasEntry(FILE_WEBEXT_MANIFEST)) {
|
|
if (!aZipReader.hasEntry(FILE_INSTALL_MANIFEST)) {
|
|
throw {
|
|
name: "UnsupportedExtension",
|
|
message: Services.appinfo.name + " does not support WebExtensions",
|
|
webext: true
|
|
};
|
|
}
|
|
}
|
|
|
|
#ifndef MOZ_JETPACK
|
|
// If Jetpack is not built throw an error
|
|
if (aZipReader.hasEntry(FILE_JETPACK_MANIFEST_1) ||
|
|
aZipReader.hasEntry(FILE_JETPACK_MANIFEST_2)) {
|
|
throw {
|
|
name: "UnsupportedExtension",
|
|
message: Services.appinfo.name + " does not support Jetpack Extensions",
|
|
jetpacksdk: true
|
|
};
|
|
}
|
|
#endif
|
|
|
|
// Attempt to open install.rdf else throw normally
|
|
let zis = aZipReader.getInputStream(FILE_INSTALL_MANIFEST);
|
|
// Create a buffered input stream for install.rdf
|
|
let bis = Cc["@mozilla.org/network/buffered-input-stream;1"].
|
|
createInstance(Ci.nsIBufferedInputStream);
|
|
bis.init(zis, 4096);
|
|
|
|
try {
|
|
let uri = buildJarURI(aZipReader.file, FILE_INSTALL_MANIFEST);
|
|
let addon = loadManifestFromRDF(uri, bis);
|
|
addon._sourceBundle = aZipReader.file;
|
|
|
|
addon.size = 0;
|
|
let entries = aZipReader.findEntries(null);
|
|
while (entries.hasMore())
|
|
addon.size += aZipReader.getEntry(entries.getNext()).realSize;
|
|
|
|
// Binary components can only be loaded from unpacked addons.
|
|
if (addon.unpack) {
|
|
uri = buildJarURI(aZipReader.file, "chrome.manifest");
|
|
let chromeManifest = ChromeManifestParser.parseSync(uri);
|
|
addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest,
|
|
"binary-component");
|
|
} else {
|
|
addon.hasBinaryComponents = false;
|
|
}
|
|
|
|
addon.appDisabled = !isUsableAddon(addon);
|
|
return addon;
|
|
}
|
|
finally {
|
|
// Close the buffered input stream
|
|
bis.close();
|
|
// Close the input stream to install.rdf
|
|
zis.close();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads an AddonInternal object from an add-on in an XPI file.
|
|
*
|
|
* @param aXPIFile
|
|
* An nsIFile pointing to the add-on's XPI file
|
|
* @return an AddonInternal object
|
|
* @throws if the XPI file does not contain a valid install manifest
|
|
*/
|
|
function loadManifestFromZipFile(aXPIFile) {
|
|
let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
|
|
createInstance(Ci.nsIZipReader);
|
|
try {
|
|
zipReader.open(aXPIFile);
|
|
|
|
return loadManifestFromZipReader(zipReader);
|
|
}
|
|
finally {
|
|
zipReader.close();
|
|
}
|
|
}
|
|
|
|
function loadManifestFromFile(aFile) {
|
|
if (aFile.isFile())
|
|
return loadManifestFromZipFile(aFile);
|
|
else
|
|
return loadManifestFromDir(aFile);
|
|
}
|
|
|
|
/**
|
|
* Gets an nsIURI for a file within another file, either a directory or an XPI
|
|
* file. If aFile is a directory then this will return a file: URI, if it is an
|
|
* XPI file then it will return a jar: URI.
|
|
*
|
|
* @param aFile
|
|
* The file containing the resources, must be either a directory or an
|
|
* XPI file
|
|
* @param aPath
|
|
* The path to find the resource at, "/" separated. If aPath is empty
|
|
* then the uri to the root of the contained files will be returned
|
|
* @return an nsIURI pointing at the resource
|
|
*/
|
|
function getURIForResourceInFile(aFile, aPath) {
|
|
if (aFile.isDirectory()) {
|
|
let resource = aFile.clone();
|
|
if (aPath) {
|
|
aPath.split("/").forEach(function(aPart) {
|
|
resource.append(aPart);
|
|
});
|
|
}
|
|
return NetUtil.newURI(resource);
|
|
}
|
|
|
|
return buildJarURI(aFile, aPath);
|
|
}
|
|
|
|
/**
|
|
* Creates a jar: URI for a file inside a ZIP file.
|
|
*
|
|
* @param aJarfile
|
|
* The ZIP file as an nsIFile
|
|
* @param aPath
|
|
* The path inside the ZIP file
|
|
* @return an nsIURI for the file
|
|
*/
|
|
function buildJarURI(aJarfile, aPath) {
|
|
let uri = Services.io.newFileURI(aJarfile);
|
|
uri = "jar:" + uri.spec + "!/" + aPath;
|
|
return NetUtil.newURI(uri);
|
|
}
|
|
|
|
/**
|
|
* Sends local and remote notifications to flush a JAR file cache entry
|
|
*
|
|
* @param aJarFile
|
|
* The ZIP/XPI/JAR file as a nsIFile
|
|
*/
|
|
function flushJarCache(aJarFile) {
|
|
Services.obs.notifyObservers(aJarFile, "flush-cache-entry", null);
|
|
Services.mm.broadcastAsyncMessage(MSG_JAR_FLUSH, aJarFile.path);
|
|
}
|
|
|
|
function flushChromeCaches() {
|
|
// Init this, so it will get the notification.
|
|
Services.obs.notifyObservers(null, "startupcache-invalidate", null);
|
|
// Flush message manager cached scripts
|
|
Services.obs.notifyObservers(null, "message-manager-flush-caches", null);
|
|
// Also dispatch this event to child processes
|
|
Services.mm.broadcastAsyncMessage(MSG_MESSAGE_MANAGER_CACHES_FLUSH, null);
|
|
}
|
|
|
|
/**
|
|
* Creates and returns a new unique temporary file. The caller should delete
|
|
* the file when it is no longer needed.
|
|
*
|
|
* @return an nsIFile that points to a randomly named, initially empty file in
|
|
* the OS temporary files directory
|
|
*/
|
|
function getTemporaryFile() {
|
|
let file = FileUtils.getDir(KEY_TEMPDIR, []);
|
|
let random = Math.random().toString(36).replace(/0./, '').substr(-3);
|
|
file.append("tmp-" + random + ".xpi");
|
|
file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
|
|
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* Verifies that a zip file's contents are all signed by the same principal.
|
|
* Directory entries and anything in the META-INF directory are not checked.
|
|
*
|
|
* @param aZip
|
|
* A nsIZipReader to check
|
|
* @param aCertificate
|
|
* The nsIX509Cert to compare against
|
|
* @return true if all the contents that should be signed were signed by the
|
|
* principal
|
|
*/
|
|
function verifyZipSigning(aZip, aCertificate) {
|
|
var count = 0;
|
|
var entries = aZip.findEntries(null);
|
|
while (entries.hasMore()) {
|
|
var entry = entries.getNext();
|
|
// Nothing in META-INF is in the manifest.
|
|
if (entry.substr(0, 9) == "META-INF/")
|
|
continue;
|
|
// Directory entries aren't in the manifest.
|
|
if (entry.substr(-1) == "/")
|
|
continue;
|
|
count++;
|
|
var entryCertificate = aZip.getSigningCert(entry);
|
|
if (!entryCertificate || !aCertificate.equals(entryCertificate)) {
|
|
return false;
|
|
}
|
|
}
|
|
return aZip.manifestEntriesCount == count;
|
|
}
|
|
|
|
/**
|
|
* Replaces %...% strings in an addon url (update and updateInfo) with
|
|
* appropriate values.
|
|
*
|
|
* @param aAddon
|
|
* The AddonInternal representing the add-on
|
|
* @param aUri
|
|
* The uri to escape
|
|
* @param aUpdateType
|
|
* An optional number representing the type of update, only applicable
|
|
* when creating a url for retrieving an update manifest
|
|
* @param aAppVersion
|
|
* The optional application version to use for %APP_VERSION%
|
|
* @return the appropriately escaped uri.
|
|
*/
|
|
function escapeAddonURI(aAddon, aUri, aUpdateType, aAppVersion)
|
|
{
|
|
let uri = AddonManager.escapeAddonURI(aAddon, aUri, aAppVersion);
|
|
|
|
// If there is an updateType then replace the UPDATE_TYPE string
|
|
if (aUpdateType)
|
|
uri = uri.replace(/%UPDATE_TYPE%/g, aUpdateType);
|
|
|
|
// If this add-on has compatibility information for either the current
|
|
// application or toolkit then replace the ITEM_MAXAPPVERSION with the
|
|
// maxVersion
|
|
let app = aAddon.matchingTargetApplication;
|
|
if (app)
|
|
var maxVersion = app.maxVersion;
|
|
else
|
|
maxVersion = "";
|
|
uri = uri.replace(/%ITEM_MAXAPPVERSION%/g, maxVersion);
|
|
|
|
let compatMode = "normal";
|
|
if (!AddonManager.checkCompatibility)
|
|
compatMode = "ignore";
|
|
else if (AddonManager.strictCompatibility)
|
|
compatMode = "strict";
|
|
uri = uri.replace(/%COMPATIBILITY_MODE%/g, compatMode);
|
|
|
|
return uri;
|
|
}
|
|
|
|
function removeAsync(aFile) {
|
|
return Task.spawn(function () {
|
|
let info = null;
|
|
try {
|
|
info = yield OS.File.stat(aFile.path);
|
|
if (info.isDir)
|
|
yield OS.File.removeDir(aFile.path);
|
|
else
|
|
yield OS.File.remove(aFile.path);
|
|
}
|
|
catch (e if e instanceof OS.File.Error && e.becauseNoSuchFile) {
|
|
// The file has already gone away
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Recursively removes a directory or file fixing permissions when necessary.
|
|
*
|
|
* @param aFile
|
|
* The nsIFile to remove
|
|
*/
|
|
function recursiveRemove(aFile) {
|
|
let isDir = null;
|
|
|
|
try {
|
|
isDir = aFile.isDirectory();
|
|
}
|
|
catch (e) {
|
|
// If the file has already gone away then don't worry about it, this can
|
|
// happen on OSX where the resource fork is automatically moved with the
|
|
// data fork for the file. See bug 733436.
|
|
if (e.result == Cr.NS_ERROR_FILE_TARGET_DOES_NOT_EXIST)
|
|
return;
|
|
if (e.result == Cr.NS_ERROR_FILE_NOT_FOUND)
|
|
return;
|
|
|
|
throw e;
|
|
}
|
|
|
|
setFilePermissions(aFile, isDir ? FileUtils.PERMS_DIRECTORY
|
|
: FileUtils.PERMS_FILE);
|
|
|
|
try {
|
|
aFile.remove(true);
|
|
return;
|
|
}
|
|
catch (e) {
|
|
if (!aFile.isDirectory()) {
|
|
logger.error("Failed to remove file " + aFile.path, e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
// Use a snapshot of the directory contents to avoid possible issues with
|
|
// iterating over a directory while removing files from it (the YAFFS2
|
|
// embedded filesystem has this issue, see bug 772238), and to remove
|
|
// normal files before their resource forks on OSX (see bug 733436).
|
|
let entries = getDirectoryEntries(aFile, true);
|
|
entries.forEach(recursiveRemove);
|
|
|
|
try {
|
|
aFile.remove(true);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to remove empty directory " + aFile.path, e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the timestamp and leaf file name of the most recently modified
|
|
* entry in a directory,
|
|
* or simply the file's own timestamp if it is not a directory.
|
|
* Also returns the total number of items (directories and files) visited in the scan
|
|
*
|
|
* @param aFile
|
|
* A non-null nsIFile object
|
|
* @return [File Name, Epoch time, items visited], as described above.
|
|
*/
|
|
function recursiveLastModifiedTime(aFile) {
|
|
try {
|
|
let modTime = aFile.lastModifiedTime;
|
|
let fileName = aFile.leafName;
|
|
if (aFile.isFile())
|
|
return [fileName, modTime, 1];
|
|
|
|
if (aFile.isDirectory()) {
|
|
let entries = aFile.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
|
|
let entry;
|
|
let totalItems = 1;
|
|
while ((entry = entries.nextFile)) {
|
|
let [subName, subTime, items] = recursiveLastModifiedTime(entry);
|
|
totalItems += items;
|
|
if (subTime > modTime) {
|
|
modTime = subTime;
|
|
fileName = subName;
|
|
}
|
|
}
|
|
entries.close();
|
|
return [fileName, modTime, totalItems];
|
|
}
|
|
}
|
|
catch (e) {
|
|
logger.warn("Problem getting last modified time for " + aFile.path, e);
|
|
}
|
|
|
|
// If the file is something else, just ignore it.
|
|
return ["", 0, 0];
|
|
}
|
|
|
|
/**
|
|
* Gets a snapshot of directory entries.
|
|
*
|
|
* @param aDir
|
|
* Directory to look at
|
|
* @param aSortEntries
|
|
* True to sort entries by filename
|
|
* @return An array of nsIFile, or an empty array if aDir is not a readable directory
|
|
*/
|
|
function getDirectoryEntries(aDir, aSortEntries) {
|
|
let dirEnum;
|
|
try {
|
|
dirEnum = aDir.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
|
|
let entries = [];
|
|
while (dirEnum.hasMoreElements())
|
|
entries.push(dirEnum.nextFile);
|
|
|
|
if (aSortEntries) {
|
|
entries.sort(function sortDirEntries(a, b) {
|
|
return a.path > b.path ? -1 : 1;
|
|
});
|
|
}
|
|
|
|
return entries
|
|
}
|
|
catch (e) {
|
|
logger.warn("Can't iterate directory " + aDir.path, e);
|
|
return [];
|
|
}
|
|
finally {
|
|
if (dirEnum) {
|
|
dirEnum.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wraps a function in an exception handler to protect against exceptions inside callbacks
|
|
* @param aFunction function(args...)
|
|
* @return function(args...), a function that takes the same arguments as aFunction
|
|
* and returns the same result unless aFunction throws, in which case it logs
|
|
* a warning and returns undefined.
|
|
*/
|
|
function makeSafe(aFunction) {
|
|
return function(...aArgs) {
|
|
try {
|
|
return aFunction(...aArgs);
|
|
}
|
|
catch(ex) {
|
|
logger.warn("XPIProvider callback failed", ex);
|
|
}
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The on-disk state of an individual XPI, created from an Object
|
|
* as stored in the 'extensions.xpiState' pref.
|
|
*/
|
|
function XPIState(saved) {
|
|
for (let [short, long] of XPIState.prototype.fields) {
|
|
if (short in saved) {
|
|
this[long] = saved[short];
|
|
}
|
|
}
|
|
}
|
|
|
|
XPIState.prototype = {
|
|
fields: [['d', 'descriptor'],
|
|
['e', 'enabled'],
|
|
['v', 'version'],
|
|
['st', 'scanTime'],
|
|
['mt', 'manifestTime']],
|
|
/**
|
|
* Return the last modified time, based on enabled/disabled
|
|
*/
|
|
get mtime() {
|
|
if (!this.enabled && ('manifestTime' in this) && this.manifestTime > this.scanTime) {
|
|
return this.manifestTime;
|
|
}
|
|
return this.scanTime;
|
|
},
|
|
|
|
toJSON() {
|
|
let json = {};
|
|
for (let [short, long] of XPIState.prototype.fields) {
|
|
if (long in this) {
|
|
json[short] = this[long];
|
|
}
|
|
}
|
|
return json;
|
|
},
|
|
|
|
/**
|
|
* Update the last modified time for an add-on on disk.
|
|
* @param aFile: nsIFile path of the add-on.
|
|
* @param aId: The add-on ID.
|
|
* @return True if the time stamp has changed.
|
|
*/
|
|
getModTime(aFile, aId) {
|
|
let changed = false;
|
|
let scanStarted = Cu.now();
|
|
// For an unknown or enabled add-on, we do a full recursive scan.
|
|
if (!('scanTime' in this) || this.enabled) {
|
|
logger.debug('getModTime: Recursive scan of ' + aId);
|
|
let [modFile, modTime, items] = recursiveLastModifiedTime(aFile);
|
|
XPIProvider._mostRecentlyModifiedFile[aId] = modFile;
|
|
if (modTime != this.scanTime) {
|
|
this.scanTime = modTime;
|
|
changed = true;
|
|
}
|
|
}
|
|
// if the add-on is disabled, modified time is the install.rdf time, if any.
|
|
// If {path}/install.rdf doesn't exist, we assume this is a packed .xpi and use
|
|
// the time stamp of {path}
|
|
try {
|
|
// Get the install.rdf update time, if any.
|
|
// XXX This will eventually also need to check for package.json or whatever
|
|
// the new manifest is named.
|
|
let maniFile = aFile.clone();
|
|
maniFile.append(FILE_INSTALL_MANIFEST);
|
|
if (!(aId in XPIProvider._mostRecentlyModifiedFile)) {
|
|
XPIProvider._mostRecentlyModifiedFile[aId] = maniFile.leafName;
|
|
}
|
|
let maniTime = maniFile.lastModifiedTime;
|
|
if (maniTime != this.manifestTime) {
|
|
this.manifestTime = maniTime;
|
|
changed = true;
|
|
}
|
|
} catch (e) {
|
|
// No manifest
|
|
delete this.manifestTime;
|
|
try {
|
|
let dtime = aFile.lastModifiedTime;
|
|
if (dtime != this.scanTime) {
|
|
changed = true;
|
|
this.scanTime = dtime;
|
|
}
|
|
} catch (e) {
|
|
logger.warn("Can't get modified time of ${file}: ${e}", {file: aFile.path, e: e});
|
|
changed = true;
|
|
this.scanTime = 0;
|
|
}
|
|
}
|
|
return changed;
|
|
},
|
|
|
|
/**
|
|
* Update the XPIState to match an XPIDatabase entry; if 'enabled' is changed to true,
|
|
* update the last-modified time. This should probably be made async, but for now we
|
|
* don't want to maintain parallel sync and async versions of the scan.
|
|
* Caller is responsible for doing XPIStates.save() if necessary.
|
|
* @param aDBAddon The DBAddonInternal for this add-on.
|
|
* @param aUpdated The add-on was updated, so we must record new modified time.
|
|
*/
|
|
syncWithDB(aDBAddon, aUpdated = false) {
|
|
logger.debug("Updating XPIState for " + JSON.stringify(aDBAddon));
|
|
// If the add-on changes from disabled to enabled, we should re-check the modified time.
|
|
// If this is a newly found add-on, it won't have an 'enabled' field but we
|
|
// did a full recursive scan in that case, so we don't need to do it again.
|
|
// We don't use aDBAddon.active here because it's not updated until after restart.
|
|
let mustGetMod = (aDBAddon.visible && !aDBAddon.disabled && !this.enabled);
|
|
this.enabled = (aDBAddon.visible && !aDBAddon.disabled);
|
|
this.version = aDBAddon.version;
|
|
// XXX Eventually also copy bootstrap, etc.
|
|
if (aUpdated || mustGetMod) {
|
|
this.getModTime(new nsIFile(this.descriptor), aDBAddon.id);
|
|
if (this.scanTime != aDBAddon.updateDate) {
|
|
aDBAddon.updateDate = this.scanTime;
|
|
XPIDatabase.saveChanges();
|
|
}
|
|
}
|
|
},
|
|
};
|
|
|
|
// Constructor for an ES6 Map that knows how to convert itself into a
|
|
// regular object for toJSON().
|
|
function SerializableMap() {
|
|
let m = new Map();
|
|
m.toJSON = function() {
|
|
let out = {}
|
|
for (let [key, val] of m) {
|
|
out[key] = val;
|
|
}
|
|
return out;
|
|
};
|
|
return m;
|
|
}
|
|
|
|
/**
|
|
* Keeps track of the state of XPI add-ons on the file system.
|
|
*/
|
|
this.XPIStates = {
|
|
// Map(location name -> Map(add-on ID -> XPIState))
|
|
db: null,
|
|
|
|
get size() {
|
|
if (!this.db) {
|
|
return 0;
|
|
}
|
|
let count = 0;
|
|
for (let location of this.db.values()) {
|
|
count += location.size;
|
|
}
|
|
return count;
|
|
},
|
|
|
|
/**
|
|
* Load extension state data from preferences.
|
|
*/
|
|
loadExtensionState() {
|
|
let state = {};
|
|
|
|
// Clear out old directory state cache.
|
|
Preferences.reset(PREF_INSTALL_CACHE);
|
|
|
|
let cache = Preferences.get(PREF_XPI_STATE, "{}");
|
|
try {
|
|
state = JSON.parse(cache);
|
|
} catch (e) {
|
|
logger.warn("Error parsing extensions.xpiState ${state}: ${error}",
|
|
{state: cache, error: e});
|
|
}
|
|
logger.debug("Loaded add-on state from prefs: ${}", state);
|
|
return state;
|
|
},
|
|
|
|
/**
|
|
* Walk through all install locations, highest priority first,
|
|
* comparing the on-disk state of extensions to what is stored in prefs.
|
|
* @return true if anything has changed.
|
|
*/
|
|
getInstallState() {
|
|
let oldState = this.loadExtensionState();
|
|
let changed = false;
|
|
this.db = new SerializableMap();
|
|
|
|
for (let location of XPIProvider.installLocations) {
|
|
// The list of add-on like file/directory names in the install location.
|
|
let addons = location.addonLocations;
|
|
// The results of scanning this location.
|
|
let foundAddons = new SerializableMap();
|
|
|
|
// What our old state thinks should be in this location.
|
|
let locState = {};
|
|
if (location.name in oldState) {
|
|
locState = oldState[location.name];
|
|
// We've seen this location.
|
|
delete oldState[location.name];
|
|
}
|
|
|
|
for (let file of addons) {
|
|
let id = location.getIDForLocation(file);
|
|
|
|
if (!(id in locState)) {
|
|
logger.debug("New add-on ${id} in ${location}", {id: id, location: location.name});
|
|
let xpiState = new XPIState({d: file.persistentDescriptor});
|
|
changed = xpiState.getModTime(file, id) || changed;
|
|
foundAddons.set(id, xpiState);
|
|
} else {
|
|
let xpiState = new XPIState(locState[id]);
|
|
// We found this add-on in the file system
|
|
delete locState[id];
|
|
|
|
changed = xpiState.getModTime(file, id) || changed;
|
|
|
|
if (file.persistentDescriptor != xpiState.descriptor) {
|
|
xpiState.descriptor = file.persistentDescriptor;
|
|
changed = true;
|
|
}
|
|
if (changed) {
|
|
logger.debug("Changed add-on ${id} in ${location}", {id: id, location: location.name});
|
|
}
|
|
foundAddons.set(id, xpiState);
|
|
}
|
|
}
|
|
|
|
// Anything left behind in oldState was removed from the file system.
|
|
for (let id in locState) {
|
|
changed = true;
|
|
break;
|
|
}
|
|
// If we found anything, add this location to our database.
|
|
if (foundAddons.size != 0) {
|
|
this.db.set(location.name, foundAddons);
|
|
}
|
|
}
|
|
|
|
// If there's anything left in oldState, an install location that held add-ons
|
|
// was removed from the browser configuration.
|
|
for (let location in oldState) {
|
|
changed = true;
|
|
break;
|
|
}
|
|
|
|
logger.debug("getInstallState changed: ${rv}, state: ${state}",
|
|
{rv: changed, state: this.db});
|
|
return changed;
|
|
},
|
|
|
|
/**
|
|
* Get the Map of XPI states for a particular location.
|
|
* @param aLocation The name of the install location.
|
|
* @return Map (id -> XPIState) or null if there are no add-ons in the location.
|
|
*/
|
|
getLocation(aLocation) {
|
|
return this.db.get(aLocation);
|
|
},
|
|
|
|
/**
|
|
* Get the XPI state for a specific add-on in a location.
|
|
* If the state is not in our cache, return null.
|
|
* @param aLocation The name of the location where the add-on is installed.
|
|
* @param aId The add-on ID
|
|
* @return The XPIState entry for the add-on, or null.
|
|
*/
|
|
getAddon(aLocation, aId) {
|
|
let location = this.db.get(aLocation);
|
|
if (!location) {
|
|
return null;
|
|
}
|
|
return location.get(aId);
|
|
},
|
|
|
|
/**
|
|
* Find the highest priority location of an add-on by ID and return the
|
|
* location and the XPIState.
|
|
* @param aId The add-on ID
|
|
* @return [locationName, XPIState] if the add-on is found, [undefined, undefined]
|
|
* if the add-on is not found.
|
|
*/
|
|
findAddon(aId) {
|
|
// Fortunately the Map iterator returns in order of insertion, which is
|
|
// also our highest -> lowest priority order.
|
|
for (let [name, location] of this.db) {
|
|
if (location.has(aId)) {
|
|
return [name, location.get(aId)];
|
|
}
|
|
}
|
|
return [undefined, undefined];
|
|
},
|
|
|
|
/**
|
|
* Add a new XPIState for an add-on and synchronize it with the DBAddonInternal.
|
|
* @param aAddon DBAddonInternal for the new add-on.
|
|
*/
|
|
addAddon(aAddon) {
|
|
let location = this.db.get(aAddon.location);
|
|
if (!location) {
|
|
// First add-on in this location.
|
|
location = new SerializableMap();
|
|
this.db.set(aAddon.location, location);
|
|
}
|
|
logger.debug("XPIStates adding add-on ${id} in ${location}: ${descriptor}", aAddon);
|
|
let xpiState = new XPIState({d: aAddon.descriptor});
|
|
location.set(aAddon.id, xpiState);
|
|
xpiState.syncWithDB(aAddon, true);
|
|
},
|
|
|
|
/**
|
|
* Save the current state of installed add-ons.
|
|
* XXX this *totally* should be a .json file using DeferredSave...
|
|
*/
|
|
save() {
|
|
let cache = JSON.stringify(this.db);
|
|
Services.prefs.setCharPref(PREF_XPI_STATE, cache);
|
|
},
|
|
|
|
/**
|
|
* Remove the XPIState for an add-on and save the new state.
|
|
* @param aLocation The name of the add-on location.
|
|
* @param aId The ID of the add-on.
|
|
*/
|
|
removeAddon(aLocation, aId) {
|
|
logger.debug("Removing XPIState for " + aLocation + ":" + aId);
|
|
let location = this.db.get(aLocation);
|
|
if (!location) {
|
|
return;
|
|
}
|
|
location.delete(aId);
|
|
if (location.size == 0) {
|
|
this.db.delete(aLocation);
|
|
}
|
|
this.save();
|
|
},
|
|
};
|
|
|
|
this.XPIProvider = {
|
|
get name() "XPIProvider",
|
|
|
|
// An array of known install locations
|
|
installLocations: null,
|
|
// A dictionary of known install locations by name
|
|
installLocationsByName: null,
|
|
// An array of currently active AddonInstalls
|
|
installs: null,
|
|
// The default skin for the application
|
|
defaultSkin: "classic/1.0",
|
|
// The current skin used by the application
|
|
currentSkin: null,
|
|
// The selected skin to be used by the application when it is restarted. This
|
|
// will be the same as currentSkin when it is the skin to be used when the
|
|
// application is restarted
|
|
selectedSkin: null,
|
|
// The value of the minCompatibleAppVersion preference
|
|
minCompatibleAppVersion: null,
|
|
// The value of the minCompatiblePlatformVersion preference
|
|
minCompatiblePlatformVersion: null,
|
|
// A dictionary of the file descriptors for bootstrappable add-ons by ID
|
|
bootstrappedAddons: {},
|
|
// A dictionary of JS scopes of loaded bootstrappable add-ons by ID
|
|
bootstrapScopes: {},
|
|
// True if the platform could have activated extensions
|
|
extensionsActive: false,
|
|
// True if all of the add-ons found during startup were installed in the
|
|
// application install location
|
|
allAppGlobal: true,
|
|
// A string listing the enabled add-ons for annotating crash reports
|
|
enabledAddons: null,
|
|
// Keep track of startup phases for telemetry
|
|
runPhase: XPI_STARTING,
|
|
// Keep track of the newest file in each add-on, in case we want to
|
|
// report it to telemetry.
|
|
_mostRecentlyModifiedFile: {},
|
|
// Per-addon telemetry information
|
|
_telemetryDetails: {},
|
|
// Experiments are disabled by default. Track ones that are locally enabled.
|
|
_enabledExperiments: null,
|
|
// A Map from an add-on install to its ID
|
|
_addonFileMap: new Map(),
|
|
#ifdef MOZ_DEVTOOLS
|
|
// Flag to know if ToolboxProcess.jsm has already been loaded by someone or not
|
|
_toolboxProcessLoaded: false,
|
|
#endif
|
|
// Have we started shutting down bootstrap add-ons?
|
|
_closing: false,
|
|
|
|
// Keep track of in-progress operations that support cancel()
|
|
_inProgress: [],
|
|
|
|
doing: function XPI_doing(aCancellable) {
|
|
this._inProgress.push(aCancellable);
|
|
},
|
|
|
|
done: function XPI_done(aCancellable) {
|
|
let i = this._inProgress.indexOf(aCancellable);
|
|
if (i != -1) {
|
|
this._inProgress.splice(i, 1);
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
|
|
cancelAll: function XPI_cancelAll() {
|
|
// Cancelling one may alter _inProgress, so don't use a simple iterator
|
|
while (this._inProgress.length > 0) {
|
|
let c = this._inProgress.shift();
|
|
try {
|
|
c.cancel();
|
|
}
|
|
catch (e) {
|
|
logger.warn("Cancel failed", e);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Adds or updates a URI mapping for an Addon.id.
|
|
*
|
|
* Mappings should not be removed at any point. This is so that the mappings
|
|
* will be still valid after an add-on gets disabled or uninstalled, as
|
|
* consumers may still have URIs of (leaked) resources they want to map.
|
|
*/
|
|
_addURIMapping: function XPI__addURIMapping(aID, aFile) {
|
|
logger.info("Mapping " + aID + " to " + aFile.path);
|
|
this._addonFileMap.set(aID, aFile.path);
|
|
|
|
AddonPathService.insertPath(aFile.path, aID);
|
|
},
|
|
|
|
/**
|
|
* Resolve a URI back to physical file.
|
|
*
|
|
* Of course, this works only for URIs pointing to local resources.
|
|
*
|
|
* @param aURI
|
|
* URI to resolve
|
|
* @return
|
|
* resolved nsIFileURL
|
|
*/
|
|
_resolveURIToFile: function XPI__resolveURIToFile(aURI) {
|
|
switch (aURI.scheme) {
|
|
case "jar":
|
|
case "file":
|
|
if (aURI instanceof Ci.nsIJARURI) {
|
|
return this._resolveURIToFile(aURI.JARFile);
|
|
}
|
|
return aURI;
|
|
|
|
case "chrome":
|
|
aURI = ChromeRegistry.convertChromeURL(aURI);
|
|
return this._resolveURIToFile(aURI);
|
|
|
|
case "resource":
|
|
aURI = Services.io.newURI(ResProtocolHandler.resolveURI(aURI), null,
|
|
null);
|
|
return this._resolveURIToFile(aURI);
|
|
|
|
case "view-source":
|
|
aURI = Services.io.newURI(aURI.path, null, null);
|
|
return this._resolveURIToFile(aURI);
|
|
|
|
case "about":
|
|
if (aURI.spec == "about:blank") {
|
|
// Do not attempt to map about:blank
|
|
return null;
|
|
}
|
|
|
|
let chan;
|
|
try {
|
|
chan = NetUtil.newChannel({
|
|
uri: aURI,
|
|
loadUsingSystemPrincipal: true
|
|
});
|
|
}
|
|
catch (ex) {
|
|
return null;
|
|
}
|
|
// Avoid looping
|
|
if (chan.URI.equals(aURI)) {
|
|
return null;
|
|
}
|
|
// We want to clone the channel URI to avoid accidentially keeping
|
|
// unnecessary references to the channel or implementation details
|
|
// around.
|
|
return this._resolveURIToFile(chan.URI.clone());
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Starts the XPI provider initializes the install locations and prefs.
|
|
*
|
|
* @param aAppChanged
|
|
* A tri-state value. Undefined means the current profile was created
|
|
* for this session, true means the profile already existed but was
|
|
* last used with an application with a different version number,
|
|
* false means that the profile was last used by this version of the
|
|
* application.
|
|
* @param aOldAppVersion
|
|
* The version of the application last run with this profile or null
|
|
* if it is a new profile or the version is unknown
|
|
* @param aOldPlatformVersion
|
|
* The version of the platform last run with this profile or null
|
|
* if it is a new profile or the version is unknown
|
|
*/
|
|
startup: function XPI_startup(aAppChanged, aOldAppVersion, aOldPlatformVersion) {
|
|
function addDirectoryInstallLocation(aName, aKey, aPaths, aScope, aLocked) {
|
|
try {
|
|
var dir = FileUtils.getDir(aKey, aPaths);
|
|
}
|
|
catch (e) {
|
|
// Some directories aren't defined on some platforms, ignore them
|
|
logger.debug("Skipping unavailable install location " + aName);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
var location = new DirectoryInstallLocation(aName, dir, aScope, aLocked);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to add directory install location " + aName, e);
|
|
return;
|
|
}
|
|
|
|
XPIProvider.installLocations.push(location);
|
|
XPIProvider.installLocationsByName[location.name] = location;
|
|
}
|
|
|
|
function addRegistryInstallLocation(aName, aRootkey, aScope) {
|
|
try {
|
|
var location = new WinRegInstallLocation(aName, aRootkey, aScope);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to add registry install location " + aName, e);
|
|
return;
|
|
}
|
|
|
|
XPIProvider.installLocations.push(location);
|
|
XPIProvider.installLocationsByName[location.name] = location;
|
|
}
|
|
|
|
try {
|
|
AddonManagerPrivate.recordTimestamp("XPI_startup_begin");
|
|
|
|
logger.debug("startup");
|
|
this.runPhase = XPI_STARTING;
|
|
this.installs = [];
|
|
this.installLocations = [];
|
|
this.installLocationsByName = {};
|
|
// Hook for tests to detect when saving database at shutdown time fails
|
|
this._shutdownError = null;
|
|
// Clear this at startup for xpcshell test restarts
|
|
this._telemetryDetails = {};
|
|
// Clear the set of enabled experiments (experiments disabled by default).
|
|
this._enabledExperiments = new Set();
|
|
|
|
let hasRegistry = ("nsIWindowsRegKey" in Ci);
|
|
|
|
let enabledScopes = Preferences.get(PREF_EM_ENABLED_SCOPES,
|
|
AddonManager.SCOPE_ALL);
|
|
|
|
// These must be in order of priority, highest to lowest,
|
|
// for processFileChanges etc. to work
|
|
// The profile location is always enabled
|
|
addDirectoryInstallLocation(KEY_APP_PROFILE, KEY_PROFILEDIR,
|
|
[DIR_EXTENSIONS],
|
|
AddonManager.SCOPE_PROFILE, false);
|
|
|
|
if (enabledScopes & AddonManager.SCOPE_USER) {
|
|
addDirectoryInstallLocation(KEY_APP_SYSTEM_USER, "XREUSysExt",
|
|
[Services.appinfo.ID],
|
|
AddonManager.SCOPE_USER, true);
|
|
if (hasRegistry) {
|
|
addRegistryInstallLocation("winreg-app-user",
|
|
Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
|
|
AddonManager.SCOPE_USER);
|
|
}
|
|
}
|
|
|
|
if (enabledScopes & AddonManager.SCOPE_APPLICATION) {
|
|
addDirectoryInstallLocation(KEY_APP_GLOBAL, KEY_APPDIR,
|
|
[DIR_EXTENSIONS],
|
|
AddonManager.SCOPE_APPLICATION, true);
|
|
}
|
|
|
|
if (enabledScopes & AddonManager.SCOPE_SYSTEM) {
|
|
addDirectoryInstallLocation(KEY_APP_SYSTEM_SHARE, "XRESysSExtPD",
|
|
[Services.appinfo.ID],
|
|
AddonManager.SCOPE_SYSTEM, true);
|
|
addDirectoryInstallLocation(KEY_APP_SYSTEM_LOCAL, "XRESysLExtPD",
|
|
[Services.appinfo.ID],
|
|
AddonManager.SCOPE_SYSTEM, true);
|
|
if (hasRegistry) {
|
|
addRegistryInstallLocation("winreg-app-global",
|
|
Ci.nsIWindowsRegKey.ROOT_KEY_LOCAL_MACHINE,
|
|
AddonManager.SCOPE_SYSTEM);
|
|
}
|
|
}
|
|
|
|
let defaultPrefs = new Preferences({ defaultBranch: true });
|
|
this.defaultSkin = defaultPrefs.get(PREF_GENERAL_SKINS_SELECTEDSKIN,
|
|
"classic/1.0");
|
|
this.currentSkin = Preferences.get(PREF_GENERAL_SKINS_SELECTEDSKIN,
|
|
this.defaultSkin);
|
|
this.selectedSkin = this.currentSkin;
|
|
this.applyThemeChange();
|
|
|
|
this.minCompatibleAppVersion = Preferences.get(PREF_EM_MIN_COMPAT_APP_VERSION,
|
|
null);
|
|
this.minCompatiblePlatformVersion = Preferences.get(PREF_EM_MIN_COMPAT_PLATFORM_VERSION,
|
|
null);
|
|
this.enabledAddons = "";
|
|
|
|
Services.prefs.addObserver(PREF_EM_MIN_COMPAT_APP_VERSION, this, false);
|
|
Services.prefs.addObserver(PREF_EM_MIN_COMPAT_PLATFORM_VERSION, this, false);
|
|
Services.obs.addObserver(this, NOTIFICATION_FLUSH_PERMISSIONS, false);
|
|
|
|
#ifdef MOZ_DEVTOOLS
|
|
if (Cu.isModuleLoaded("resource://devtools/client/framework/ToolboxProcess.jsm")) {
|
|
// If BrowserToolboxProcess is already loaded, set the boolean to true
|
|
// and do whatever is needed
|
|
this._toolboxProcessLoaded = true;
|
|
BrowserToolboxProcess.on("connectionchange",
|
|
this.onDebugConnectionChange.bind(this));
|
|
}
|
|
else {
|
|
// Else, wait for it to load
|
|
Services.obs.addObserver(this, NOTIFICATION_TOOLBOXPROCESS_LOADED, false);
|
|
}
|
|
#endif
|
|
|
|
let flushCaches = this.checkForChanges(aAppChanged, aOldAppVersion,
|
|
aOldPlatformVersion);
|
|
|
|
// Changes to installed extensions may have changed which theme is selected
|
|
this.applyThemeChange();
|
|
|
|
AddonManagerPrivate.markProviderSafe(this);
|
|
|
|
if (aAppChanged === undefined) {
|
|
// For new profiles we will never need to show the add-on selection UI
|
|
Services.prefs.setBoolPref(PREF_SHOWN_SELECTION_UI, true);
|
|
}
|
|
else if (aAppChanged && !this.allAppGlobal &&
|
|
Preferences.get(PREF_EM_SHOW_MISMATCH_UI, true)) {
|
|
if (!Preferences.get(PREF_SHOWN_SELECTION_UI, false)) {
|
|
// Flip a flag to indicate that we interrupted startup with an interactive prompt
|
|
Services.startup.interrupted = true;
|
|
// This *must* be modal as it has to block startup.
|
|
var features = "chrome,centerscreen,dialog,titlebar,modal";
|
|
Services.ww.openWindow(null, URI_EXTENSION_SELECT_DIALOG, "", features, null);
|
|
Services.prefs.setBoolPref(PREF_SHOWN_SELECTION_UI, true);
|
|
// Ensure any changes to the add-ons list are flushed to disk
|
|
Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
|
|
!XPIDatabase.writeAddonsList());
|
|
}
|
|
else {
|
|
let addonsToUpdate = this.shouldForceUpdateCheck(aAppChanged);
|
|
if (addonsToUpdate) {
|
|
this.showUpgradeUI(addonsToUpdate);
|
|
flushCaches = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (flushCaches) {
|
|
Services.obs.notifyObservers(null, "startupcache-invalidate", null);
|
|
// UI displayed early in startup (like the compatibility UI) may have
|
|
// caused us to cache parts of the skin or locale in memory. These must
|
|
// be flushed to allow extension provided skins and locales to take full
|
|
// effect
|
|
Services.obs.notifyObservers(null, "chrome-flush-skin-caches", null);
|
|
Services.obs.notifyObservers(null, "chrome-flush-caches", null);
|
|
}
|
|
|
|
this.enabledAddons = Preferences.get(PREF_EM_ENABLED_ADDONS, "");
|
|
|
|
if ("nsICrashReporter" in Ci &&
|
|
Services.appinfo instanceof Ci.nsICrashReporter) {
|
|
// Annotate the crash report with relevant add-on information.
|
|
try {
|
|
Services.appinfo.annotateCrashReport("Theme", this.currentSkin);
|
|
} catch (e) { }
|
|
try {
|
|
Services.appinfo.annotateCrashReport("EMCheckCompatibility",
|
|
AddonManager.checkCompatibility);
|
|
} catch (e) { }
|
|
this.addAddonsToCrashReporter();
|
|
}
|
|
|
|
try {
|
|
AddonManagerPrivate.recordTimestamp("XPI_bootstrap_addons_begin");
|
|
for (let id in this.bootstrappedAddons) {
|
|
try {
|
|
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
|
|
file.persistentDescriptor = this.bootstrappedAddons[id].descriptor;
|
|
let reason = BOOTSTRAP_REASONS.APP_STARTUP;
|
|
// Eventually set INSTALLED reason when a bootstrap addon
|
|
// is dropped in profile folder and automatically installed
|
|
if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_INSTALLED)
|
|
.indexOf(id) !== -1)
|
|
reason = BOOTSTRAP_REASONS.ADDON_INSTALL;
|
|
this.callBootstrapMethod(createAddonDetails(id, this.bootstrappedAddons[id]),
|
|
file, "startup", reason);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to load bootstrap addon " + id + " from " +
|
|
this.bootstrappedAddons[id].descriptor, e);
|
|
}
|
|
}
|
|
AddonManagerPrivate.recordTimestamp("XPI_bootstrap_addons_end");
|
|
}
|
|
catch (e) {
|
|
logger.error("bootstrap startup failed", e);
|
|
AddonManagerPrivate.recordException("XPI-BOOTSTRAP", "startup failed", e);
|
|
}
|
|
|
|
// Let these shutdown a little earlier when they still have access to most
|
|
// of XPCOM
|
|
Services.obs.addObserver({
|
|
observe: function shutdownObserver(aSubject, aTopic, aData) {
|
|
XPIProvider._closing = true;
|
|
for (let id in XPIProvider.bootstrappedAddons) {
|
|
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
|
|
file.persistentDescriptor = XPIProvider.bootstrappedAddons[id].descriptor;
|
|
let addon = createAddonDetails(id, XPIProvider.bootstrappedAddons[id]);
|
|
XPIProvider.callBootstrapMethod(addon, file, "shutdown",
|
|
BOOTSTRAP_REASONS.APP_SHUTDOWN);
|
|
}
|
|
Services.obs.removeObserver(this, "quit-application-granted");
|
|
}
|
|
}, "quit-application-granted", false);
|
|
|
|
// Detect final-ui-startup for telemetry reporting
|
|
Services.obs.addObserver({
|
|
observe: function uiStartupObserver(aSubject, aTopic, aData) {
|
|
AddonManagerPrivate.recordTimestamp("XPI_finalUIStartup");
|
|
XPIProvider.runPhase = XPI_AFTER_UI_STARTUP;
|
|
Services.obs.removeObserver(this, "final-ui-startup");
|
|
}
|
|
}, "final-ui-startup", false);
|
|
|
|
AddonManagerPrivate.recordTimestamp("XPI_startup_end");
|
|
|
|
this.extensionsActive = true;
|
|
this.runPhase = XPI_BEFORE_UI_STARTUP;
|
|
}
|
|
catch (e) {
|
|
logger.error("startup failed", e);
|
|
AddonManagerPrivate.recordException("XPI", "startup failed", e);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Shuts down the database and releases all references.
|
|
* Return: Promise{integer} resolves / rejects with the result of
|
|
* flushing the XPI Database if it was loaded,
|
|
* 0 otherwise.
|
|
*/
|
|
shutdown: function XPI_shutdown() {
|
|
logger.debug("shutdown");
|
|
|
|
// Stop anything we were doing asynchronously
|
|
this.cancelAll();
|
|
|
|
this.bootstrappedAddons = {};
|
|
this.bootstrapScopes = {};
|
|
this.enabledAddons = null;
|
|
this.allAppGlobal = true;
|
|
|
|
// If there are pending operations then we must update the list of active
|
|
// add-ons
|
|
if (Preferences.get(PREF_PENDING_OPERATIONS, false)) {
|
|
AddonManagerPrivate.recordSimpleMeasure("XPIDB_pending_ops", 1);
|
|
XPIDatabase.updateActiveAddons();
|
|
Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
|
|
!XPIDatabase.writeAddonsList());
|
|
}
|
|
|
|
this.installs = null;
|
|
this.installLocations = null;
|
|
this.installLocationsByName = null;
|
|
|
|
// This is needed to allow xpcshell tests to simulate a restart
|
|
this.extensionsActive = false;
|
|
this._addonFileMap.clear();
|
|
|
|
if (gLazyObjectsLoaded) {
|
|
let done = XPIDatabase.shutdown();
|
|
done.then(
|
|
ret => {
|
|
logger.debug("Notifying XPI shutdown observers");
|
|
Services.obs.notifyObservers(null, "xpi-provider-shutdown", null);
|
|
},
|
|
err => {
|
|
logger.debug("Notifying XPI shutdown observers");
|
|
this._shutdownError = err;
|
|
Services.obs.notifyObservers(null, "xpi-provider-shutdown", err);
|
|
}
|
|
);
|
|
return done;
|
|
}
|
|
else {
|
|
logger.debug("Notifying XPI shutdown observers");
|
|
Services.obs.notifyObservers(null, "xpi-provider-shutdown", null);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Applies any pending theme change to the preferences.
|
|
*/
|
|
applyThemeChange: function XPI_applyThemeChange() {
|
|
if (!Preferences.get(PREF_DSS_SWITCHPENDING, false))
|
|
return;
|
|
|
|
// Tell the Chrome Registry which Skin to select
|
|
try {
|
|
this.selectedSkin = Preferences.get(PREF_DSS_SKIN_TO_SELECT);
|
|
Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN,
|
|
this.selectedSkin);
|
|
Services.prefs.clearUserPref(PREF_DSS_SKIN_TO_SELECT);
|
|
logger.debug("Changed skin to " + this.selectedSkin);
|
|
this.currentSkin = this.selectedSkin;
|
|
}
|
|
catch (e) {
|
|
logger.error("Error applying theme change", e);
|
|
}
|
|
Services.prefs.clearUserPref(PREF_DSS_SWITCHPENDING);
|
|
},
|
|
|
|
/**
|
|
* If the application has been upgraded and there are add-ons outside the
|
|
* application directory then we may need to synchronize compatibility
|
|
* information but only if the mismatch UI isn't disabled.
|
|
*
|
|
* @returns False if no update check is needed, otherwise an array of add-on
|
|
* IDs to check for updates. Array may be empty if no add-ons can be/need
|
|
* to be updated, but the metadata check needs to be performed.
|
|
*/
|
|
shouldForceUpdateCheck: function XPI_shouldForceUpdateCheck(aAppChanged) {
|
|
AddonManagerPrivate.recordSimpleMeasure("XPIDB_metadata_age", AddonRepository.metadataAge());
|
|
|
|
let startupChanges = AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_DISABLED);
|
|
logger.debug("shouldForceUpdateCheck startupChanges: " + startupChanges.toSource());
|
|
AddonManagerPrivate.recordSimpleMeasure("XPIDB_startup_disabled", startupChanges.length);
|
|
|
|
let forceUpdate = [];
|
|
if (startupChanges.length > 0) {
|
|
let addons = XPIDatabase.getAddons();
|
|
for (let addon of addons) {
|
|
if ((startupChanges.indexOf(addon.id) != -1) &&
|
|
(addon.permissions() & AddonManager.PERM_CAN_UPGRADE)) {
|
|
logger.debug("shouldForceUpdateCheck: can upgrade disabled add-on " + addon.id);
|
|
forceUpdate.push(addon.id);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (AddonRepository.isMetadataStale()) {
|
|
logger.debug("shouldForceUpdateCheck: metadata is stale");
|
|
return forceUpdate;
|
|
}
|
|
if (forceUpdate.length > 0) {
|
|
return forceUpdate;
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Shows the "Compatibility Updates" UI.
|
|
*
|
|
* @param aAddonIDs
|
|
* Array opf addon IDs that were disabled by the application update, and
|
|
* should therefore be checked for updates.
|
|
*/
|
|
showUpgradeUI: function XPI_showUpgradeUI(aAddonIDs) {
|
|
logger.debug("XPI_showUpgradeUI: " + aAddonIDs.toSource());
|
|
// Flip a flag to indicate that we interrupted startup with an interactive prompt
|
|
Services.startup.interrupted = true;
|
|
|
|
var variant = Cc["@mozilla.org/variant;1"].
|
|
createInstance(Ci.nsIWritableVariant);
|
|
variant.setFromVariant(aAddonIDs);
|
|
|
|
// This *must* be modal as it has to block startup.
|
|
var features = "chrome,centerscreen,dialog,titlebar,modal";
|
|
var ww = Cc["@mozilla.org/embedcomp/window-watcher;1"].
|
|
getService(Ci.nsIWindowWatcher);
|
|
ww.openWindow(null, URI_EXTENSION_UPDATE_DIALOG, "", features, variant);
|
|
|
|
// Ensure any changes to the add-ons list are flushed to disk
|
|
Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
|
|
!XPIDatabase.writeAddonsList());
|
|
},
|
|
|
|
/**
|
|
* Persists changes to XPIProvider.bootstrappedAddons to its store (a pref).
|
|
*/
|
|
persistBootstrappedAddons: function XPI_persistBootstrappedAddons() {
|
|
// Experiments are disabled upon app load, so don't persist references.
|
|
let filtered = {};
|
|
for (let id in this.bootstrappedAddons) {
|
|
let entry = this.bootstrappedAddons[id];
|
|
if (entry.type == "experiment") {
|
|
continue;
|
|
}
|
|
|
|
filtered[id] = entry;
|
|
}
|
|
|
|
Services.prefs.setCharPref(PREF_BOOTSTRAP_ADDONS,
|
|
JSON.stringify(filtered));
|
|
},
|
|
|
|
/**
|
|
* Adds a list of currently active add-ons to the next crash report.
|
|
*/
|
|
addAddonsToCrashReporter: function XPI_addAddonsToCrashReporter() {
|
|
if (!("nsICrashReporter" in Ci) ||
|
|
!(Services.appinfo instanceof Ci.nsICrashReporter))
|
|
return;
|
|
|
|
// In safe mode no add-ons are loaded so we should not include them in the
|
|
// crash report
|
|
if (Services.appinfo.inSafeMode)
|
|
return;
|
|
|
|
let data = this.enabledAddons;
|
|
for (let id in this.bootstrappedAddons) {
|
|
data += (data ? "," : "") + encodeURIComponent(id) + ":" +
|
|
encodeURIComponent(this.bootstrappedAddons[id].version);
|
|
}
|
|
|
|
try {
|
|
Services.appinfo.annotateCrashReport("Add-ons", data);
|
|
}
|
|
catch (e) { }
|
|
|
|
let TelemetrySession =
|
|
Cu.import("resource://gre/modules/TelemetrySession.jsm", {}).TelemetrySession;
|
|
TelemetrySession.setAddOns(data);
|
|
},
|
|
|
|
/**
|
|
* Check the staging directories of install locations for any add-ons to be
|
|
* installed or add-ons to be uninstalled.
|
|
*
|
|
* @param aManifests
|
|
* A dictionary to add detected install manifests to for the purpose
|
|
* of passing through updated compatibility information
|
|
* @return true if an add-on was installed or uninstalled
|
|
*/
|
|
processPendingFileChanges: function XPI_processPendingFileChanges(aManifests) {
|
|
let changed = false;
|
|
this.installLocations.forEach(function(aLocation) {
|
|
aManifests[aLocation.name] = {};
|
|
// We can't install or uninstall anything in locked locations
|
|
if (aLocation.locked)
|
|
return;
|
|
|
|
let stagedXPIDir = aLocation.getXPIStagingDir();
|
|
let stagingDir = aLocation.getStagingDir();
|
|
|
|
if (stagedXPIDir.exists() && stagedXPIDir.isDirectory()) {
|
|
let entries = stagedXPIDir.directoryEntries
|
|
.QueryInterface(Ci.nsIDirectoryEnumerator);
|
|
while (entries.hasMoreElements()) {
|
|
let stageDirEntry = entries.nextFile;
|
|
|
|
if (!stageDirEntry.isDirectory()) {
|
|
logger.warn("Ignoring file in XPI staging directory: " + stageDirEntry.path);
|
|
continue;
|
|
}
|
|
|
|
// Find the last added XPI file in the directory
|
|
let stagedXPI = null;
|
|
var xpiEntries = stageDirEntry.directoryEntries
|
|
.QueryInterface(Ci.nsIDirectoryEnumerator);
|
|
while (xpiEntries.hasMoreElements()) {
|
|
let file = xpiEntries.nextFile;
|
|
if (file.isDirectory())
|
|
continue;
|
|
|
|
let extension = file.leafName;
|
|
extension = extension.substring(extension.length - 4);
|
|
|
|
if (extension != ".xpi" && extension != ".jar")
|
|
continue;
|
|
|
|
stagedXPI = file;
|
|
}
|
|
xpiEntries.close();
|
|
|
|
if (!stagedXPI)
|
|
continue;
|
|
|
|
let addon = null;
|
|
try {
|
|
addon = loadManifestFromZipFile(stagedXPI);
|
|
}
|
|
catch (e) {
|
|
logger.error("Unable to read add-on manifest from " + stagedXPI.path, e);
|
|
continue;
|
|
}
|
|
|
|
logger.debug("Migrating staged install of " + addon.id + " in " + aLocation.name);
|
|
|
|
if (addon.unpack || Preferences.get(PREF_XPI_UNPACK, false)) {
|
|
let targetDir = stagingDir.clone();
|
|
targetDir.append(addon.id);
|
|
try {
|
|
targetDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to create staging directory for add-on " + addon.id, e);
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
ZipUtils.extractFiles(stagedXPI, targetDir);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to extract staged XPI for add-on " + addon.id + " in " +
|
|
aLocation.name, e);
|
|
}
|
|
}
|
|
else {
|
|
try {
|
|
stagedXPI.moveTo(stagingDir, addon.id + ".xpi");
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to move staged XPI for add-on " + addon.id + " in " +
|
|
aLocation.name, e);
|
|
}
|
|
}
|
|
}
|
|
entries.close();
|
|
}
|
|
|
|
if (stagedXPIDir.exists()) {
|
|
try {
|
|
recursiveRemove(stagedXPIDir);
|
|
}
|
|
catch (e) {
|
|
// Non-critical, just saves some perf on startup if we clean this up.
|
|
logger.debug("Error removing XPI staging dir " + stagedXPIDir.path, e);
|
|
}
|
|
}
|
|
|
|
try {
|
|
if (!stagingDir || !stagingDir.exists() || !stagingDir.isDirectory())
|
|
return;
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to find staging directory", e);
|
|
return;
|
|
}
|
|
|
|
let seenFiles = [];
|
|
// Use a snapshot of the directory contents to avoid possible issues with
|
|
// iterating over a directory while removing files from it (the YAFFS2
|
|
// embedded filesystem has this issue, see bug 772238), and to remove
|
|
// normal files before their resource forks on OSX (see bug 733436).
|
|
let stagingDirEntries = getDirectoryEntries(stagingDir, true);
|
|
for (let stageDirEntry of stagingDirEntries) {
|
|
let id = stageDirEntry.leafName;
|
|
|
|
let isDir;
|
|
try {
|
|
isDir = stageDirEntry.isDirectory();
|
|
}
|
|
catch (e if e.result == Cr.NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) {
|
|
// If the file has already gone away then don't worry about it, this
|
|
// can happen on OSX where the resource fork is automatically moved
|
|
// with the data fork for the file. See bug 733436.
|
|
continue;
|
|
}
|
|
|
|
if (!isDir) {
|
|
if (id.substring(id.length - 4).toLowerCase() == ".xpi") {
|
|
id = id.substring(0, id.length - 4);
|
|
}
|
|
else {
|
|
if (id.substring(id.length - 5).toLowerCase() != ".json") {
|
|
logger.warn("Ignoring file: " + stageDirEntry.path);
|
|
seenFiles.push(stageDirEntry.leafName);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Check that the directory's name is a valid ID.
|
|
if (!gIDTest.test(id)) {
|
|
logger.warn("Ignoring directory whose name is not a valid add-on ID: " +
|
|
stageDirEntry.path);
|
|
seenFiles.push(stageDirEntry.leafName);
|
|
continue;
|
|
}
|
|
|
|
changed = true;
|
|
|
|
if (isDir) {
|
|
// Check if the directory contains an install manifest.
|
|
let manifest = stageDirEntry.clone();
|
|
manifest.append(FILE_INSTALL_MANIFEST);
|
|
|
|
// If the install manifest doesn't exist uninstall this add-on in this
|
|
// install location.
|
|
if (!manifest.exists()) {
|
|
logger.debug("Processing uninstall of " + id + " in " + aLocation.name);
|
|
|
|
try {
|
|
let addonFile = aLocation.getLocationForID(id);
|
|
let addonToUninstall = loadManifestFromFile(addonFile, aLocation);
|
|
if (addonToUninstall.bootstrap) {
|
|
this.callBootstrapMethod(addonToUninstall, addonToUninstall._sourceBundle,
|
|
"uninstall", BOOTSTRAP_REASONS.ADDON_UNINSTALL);
|
|
}
|
|
}
|
|
catch (e) {
|
|
// If called on startup this may fail due to staged folder still existing.
|
|
}
|
|
|
|
try {
|
|
aLocation.uninstallAddon(id);
|
|
seenFiles.push(stageDirEntry.leafName);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to uninstall add-on " + id + " in " + aLocation.name, e);
|
|
}
|
|
// The file check later will spot the removal and cleanup the database
|
|
continue;
|
|
}
|
|
}
|
|
|
|
aManifests[aLocation.name][id] = null;
|
|
let existingAddonID = id;
|
|
|
|
let jsonfile = stagingDir.clone();
|
|
jsonfile.append(id + ".json");
|
|
|
|
try {
|
|
aManifests[aLocation.name][id] = loadManifestFromFile(stageDirEntry);
|
|
}
|
|
catch (e) {
|
|
logger.error("Unable to read add-on manifest from " + stageDirEntry.path, e);
|
|
// This add-on can't be installed so just remove it now
|
|
seenFiles.push(stageDirEntry.leafName);
|
|
seenFiles.push(jsonfile.leafName);
|
|
continue;
|
|
}
|
|
|
|
// Check for a cached metadata for this add-on, it may contain updated
|
|
// compatibility information
|
|
if (jsonfile.exists()) {
|
|
logger.debug("Found updated metadata for " + id + " in " + aLocation.name);
|
|
let fis = Cc["@mozilla.org/network/file-input-stream;1"].
|
|
createInstance(Ci.nsIFileInputStream);
|
|
let json = Cc["@mozilla.org/dom/json;1"].
|
|
createInstance(Ci.nsIJSON);
|
|
|
|
try {
|
|
fis.init(jsonfile, -1, 0, 0);
|
|
let metadata = json.decodeFromStream(fis, jsonfile.fileSize);
|
|
aManifests[aLocation.name][id].importMetadata(metadata);
|
|
}
|
|
catch (e) {
|
|
// If some data can't be recovered from the cached metadata then it
|
|
// is unlikely to be a problem big enough to justify throwing away
|
|
// the install, just log and error and continue
|
|
logger.error("Unable to read metadata from " + jsonfile.path, e);
|
|
}
|
|
finally {
|
|
fis.close();
|
|
}
|
|
}
|
|
seenFiles.push(jsonfile.leafName);
|
|
|
|
existingAddonID = aManifests[aLocation.name][id].existingAddonID || id;
|
|
|
|
var oldBootstrap = null;
|
|
logger.debug("Processing install of " + id + " in " + aLocation.name);
|
|
if (existingAddonID in this.bootstrappedAddons) {
|
|
try {
|
|
var existingAddon = aLocation.getLocationForID(existingAddonID);
|
|
if (this.bootstrappedAddons[existingAddonID].descriptor ==
|
|
existingAddon.persistentDescriptor) {
|
|
oldBootstrap = this.bootstrappedAddons[existingAddonID];
|
|
|
|
// We'll be replacing a currently active bootstrapped add-on so
|
|
// call its uninstall method
|
|
let newVersion = aManifests[aLocation.name][id].version;
|
|
let oldVersion = oldBootstrap.version;
|
|
let uninstallReason = Services.vc.compare(oldVersion, newVersion) < 0 ?
|
|
BOOTSTRAP_REASONS.ADDON_UPGRADE :
|
|
BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
|
|
|
|
this.callBootstrapMethod(createAddonDetails(existingAddonID, oldBootstrap),
|
|
existingAddon, "uninstall", uninstallReason,
|
|
{ newVersion: newVersion });
|
|
this.unloadBootstrapScope(existingAddonID);
|
|
flushChromeCaches();
|
|
}
|
|
}
|
|
catch (e) {
|
|
}
|
|
}
|
|
|
|
try {
|
|
var addonInstallLocation = aLocation.installAddon(id, stageDirEntry,
|
|
existingAddonID);
|
|
if (aManifests[aLocation.name][id])
|
|
aManifests[aLocation.name][id]._sourceBundle = addonInstallLocation;
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to install staged add-on " + id + " in " + aLocation.name,
|
|
e);
|
|
// Re-create the staged install
|
|
AddonInstall.createStagedInstall(aLocation, stageDirEntry,
|
|
aManifests[aLocation.name][id]);
|
|
// Make sure not to delete the cached manifest json file
|
|
seenFiles.pop();
|
|
|
|
delete aManifests[aLocation.name][id];
|
|
|
|
if (oldBootstrap) {
|
|
// Re-install the old add-on
|
|
this.callBootstrapMethod(createAddonDetails(existingAddonID, oldBootstrap),
|
|
existingAddon, "install",
|
|
BOOTSTRAP_REASONS.ADDON_INSTALL);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
try {
|
|
aLocation.cleanStagingDir(seenFiles);
|
|
}
|
|
catch (e) {
|
|
// Non-critical, just saves some perf on startup if we clean this up.
|
|
logger.debug("Error cleaning staging dir " + stagingDir.path, e);
|
|
}
|
|
}, this);
|
|
return changed;
|
|
},
|
|
|
|
/**
|
|
* Installs any add-ons located in the extensions directory of the
|
|
* application's distribution specific directory into the profile unless a
|
|
* newer version already exists or the user has previously uninstalled the
|
|
* distributed add-on.
|
|
*
|
|
* @param aManifests
|
|
* A dictionary to add new install manifests to to save having to
|
|
* reload them later
|
|
* @return true if any new add-ons were installed
|
|
*/
|
|
installDistributionAddons: function XPI_installDistributionAddons(aManifests) {
|
|
let distroDir;
|
|
try {
|
|
distroDir = FileUtils.getDir(KEY_APP_DISTRIBUTION, [DIR_EXTENSIONS]);
|
|
}
|
|
catch (e) {
|
|
return false;
|
|
}
|
|
|
|
if (!distroDir.exists())
|
|
return false;
|
|
|
|
if (!distroDir.isDirectory())
|
|
return false;
|
|
|
|
let changed = false;
|
|
let profileLocation = this.installLocationsByName[KEY_APP_PROFILE];
|
|
|
|
let entries = distroDir.directoryEntries
|
|
.QueryInterface(Ci.nsIDirectoryEnumerator);
|
|
let entry;
|
|
while ((entry = entries.nextFile)) {
|
|
|
|
let id = entry.leafName;
|
|
|
|
if (entry.isFile()) {
|
|
if (id.substring(id.length - 4).toLowerCase() == ".xpi") {
|
|
id = id.substring(0, id.length - 4);
|
|
}
|
|
else {
|
|
logger.debug("Ignoring distribution add-on that isn't an XPI: " + entry.path);
|
|
continue;
|
|
}
|
|
}
|
|
else if (!entry.isDirectory()) {
|
|
logger.debug("Ignoring distribution add-on that isn't a file or directory: " +
|
|
entry.path);
|
|
continue;
|
|
}
|
|
|
|
if (!gIDTest.test(id)) {
|
|
logger.debug("Ignoring distribution add-on whose name is not a valid add-on ID: " +
|
|
entry.path);
|
|
continue;
|
|
}
|
|
|
|
let addon;
|
|
try {
|
|
addon = loadManifestFromFile(entry);
|
|
}
|
|
catch (e) {
|
|
logger.warn("File entry " + entry.path + " contains an invalid add-on", e);
|
|
continue;
|
|
}
|
|
|
|
if (addon.id != id) {
|
|
logger.warn("File entry " + entry.path + " contains an add-on with an " +
|
|
"incorrect ID")
|
|
continue;
|
|
}
|
|
|
|
let existingEntry = null;
|
|
try {
|
|
existingEntry = profileLocation.getLocationForID(id);
|
|
}
|
|
catch (e) {
|
|
}
|
|
|
|
if (existingEntry) {
|
|
let existingAddon;
|
|
try {
|
|
existingAddon = loadManifestFromFile(existingEntry);
|
|
|
|
if (Services.vc.compare(addon.version, existingAddon.version) <= 0)
|
|
continue;
|
|
}
|
|
catch (e) {
|
|
// Bad add-on in the profile so just proceed and install over the top
|
|
logger.warn("Profile contains an add-on with a bad or missing install " +
|
|
"manifest at " + existingEntry.path + ", overwriting", e);
|
|
}
|
|
}
|
|
else if (Preferences.get(PREF_BRANCH_INSTALLED_ADDON + id, false)) {
|
|
continue;
|
|
}
|
|
|
|
// Install the add-on
|
|
try {
|
|
profileLocation.installAddon(id, entry, null, true);
|
|
logger.debug("Installed distribution add-on " + id);
|
|
|
|
Services.prefs.setBoolPref(PREF_BRANCH_INSTALLED_ADDON + id, true)
|
|
|
|
// aManifests may contain a copy of a newly installed add-on's manifest
|
|
// and we'll have overwritten that so instead cache our install manifest
|
|
// which will later be put into the database in processFileChanges
|
|
if (!(KEY_APP_PROFILE in aManifests))
|
|
aManifests[KEY_APP_PROFILE] = {};
|
|
aManifests[KEY_APP_PROFILE][id] = addon;
|
|
changed = true;
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to install distribution add-on " + entry.path, e);
|
|
}
|
|
}
|
|
|
|
entries.close();
|
|
|
|
return changed;
|
|
},
|
|
|
|
/**
|
|
* Compares the add-ons that are currently installed to those that were
|
|
* known to be installed when the application last ran and applies any
|
|
* changes found to the database. Also sends "startupcache-invalidate" signal to
|
|
* observerservice if it detects that data may have changed.
|
|
* Always called after XPIProviderUtils.js and extensions.json have been loaded.
|
|
*
|
|
* @param aManifests
|
|
* A dictionary of cached AddonInstalls for add-ons that have been
|
|
* installed
|
|
* @param aUpdateCompatibility
|
|
* true to update add-ons appDisabled property when the application
|
|
* version has changed
|
|
* @param aOldAppVersion
|
|
* The version of the application last run with this profile or null
|
|
* if it is a new profile or the version is unknown
|
|
* @param aOldPlatformVersion
|
|
* The version of the platform last run with this profile or null
|
|
* if it is a new profile or the version is unknown
|
|
* @return a boolean indicating if a change requiring flushing the caches was
|
|
* detected
|
|
*/
|
|
processFileChanges: function XPI_processFileChanges(aManifests,
|
|
aUpdateCompatibility,
|
|
aOldAppVersion,
|
|
aOldPlatformVersion) {
|
|
let visibleAddons = {};
|
|
let oldBootstrappedAddons = this.bootstrappedAddons;
|
|
this.bootstrappedAddons = {};
|
|
|
|
/**
|
|
* Updates an add-on's metadata and determines if a restart of the
|
|
* application is necessary. This is called when either the add-on's
|
|
* install directory path or last modified time has changed.
|
|
*
|
|
* @param aInstallLocation
|
|
* The install location containing the add-on
|
|
* @param aOldAddon
|
|
* The AddonInternal as it appeared the last time the application
|
|
* ran
|
|
* @param aAddonState
|
|
* The new state of the add-on
|
|
* @return a boolean indicating if flushing caches is required to complete
|
|
* changing this add-on
|
|
*/
|
|
function updateMetadata(aInstallLocation, aOldAddon, aAddonState) {
|
|
logger.debug("Add-on " + aOldAddon.id + " modified in " + aInstallLocation.name);
|
|
|
|
// Check if there is an updated install manifest for this add-on
|
|
let newAddon = aManifests[aInstallLocation.name][aOldAddon.id];
|
|
|
|
try {
|
|
// If not load it
|
|
if (!newAddon) {
|
|
let file = aInstallLocation.getLocationForID(aOldAddon.id);
|
|
newAddon = loadManifestFromFile(file);
|
|
applyBlocklistChanges(aOldAddon, newAddon);
|
|
|
|
// Carry over any pendingUninstall state to add-ons modified directly
|
|
// in the profile. This is important when the attempt to remove the
|
|
// add-on in processPendingFileChanges failed and caused an mtime
|
|
// change to the add-ons files.
|
|
newAddon.pendingUninstall = aOldAddon.pendingUninstall;
|
|
}
|
|
|
|
// The ID in the manifest that was loaded must match the ID of the old
|
|
// add-on.
|
|
if (newAddon.id != aOldAddon.id)
|
|
throw new Error("Incorrect id in install manifest for existing add-on " + aOldAddon.id);
|
|
}
|
|
catch (e) {
|
|
logger.warn("updateMetadata: Add-on " + aOldAddon.id + " is invalid", e);
|
|
XPIDatabase.removeAddonMetadata(aOldAddon);
|
|
XPIStates.removeAddon(aOldAddon.location, aOldAddon.id);
|
|
if (!aInstallLocation.locked)
|
|
aInstallLocation.uninstallAddon(aOldAddon.id);
|
|
else
|
|
logger.warn("Could not uninstall invalid item from locked install location");
|
|
// If this was an active add-on then we must force a restart
|
|
if (aOldAddon.active)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// Set the additional properties on the new AddonInternal
|
|
newAddon._installLocation = aInstallLocation;
|
|
newAddon.updateDate = aAddonState.mtime;
|
|
newAddon.visible = !(newAddon.id in visibleAddons);
|
|
|
|
// Update the database
|
|
let newDBAddon = XPIDatabase.updateAddonMetadata(aOldAddon, newAddon,
|
|
aAddonState.descriptor);
|
|
if (newDBAddon.visible) {
|
|
visibleAddons[newDBAddon.id] = newDBAddon;
|
|
// Remember add-ons that were changed during startup
|
|
AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
|
|
newDBAddon.id);
|
|
|
|
// If this was the active theme and it is now disabled then enable the
|
|
// default theme
|
|
if (aOldAddon.active && newDBAddon.disabled)
|
|
XPIProvider.enableDefaultTheme();
|
|
|
|
// If the new add-on is bootstrapped and active then call its install method
|
|
if (newDBAddon.active && newDBAddon.bootstrap) {
|
|
// Startup cache must be flushed before calling the bootstrap script
|
|
flushChromeCaches();
|
|
|
|
let installReason = Services.vc.compare(aOldAddon.version, newDBAddon.version) < 0 ?
|
|
BOOTSTRAP_REASONS.ADDON_UPGRADE :
|
|
BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
|
|
|
|
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
|
|
file.persistentDescriptor = aAddonState.descriptor;
|
|
XPIProvider.callBootstrapMethod(newDBAddon, file, "install",
|
|
installReason, { oldVersion: aOldAddon.version });
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Updates an add-on's descriptor for when the add-on has moved in the
|
|
* filesystem but hasn't changed in any other way.
|
|
*
|
|
* @param aInstallLocation
|
|
* The install location containing the add-on
|
|
* @param aOldAddon
|
|
* The AddonInternal as it appeared the last time the application
|
|
* ran
|
|
* @param aAddonState
|
|
* The new state of the add-on
|
|
* @return a boolean indicating if flushing caches is required to complete
|
|
* changing this add-on
|
|
*/
|
|
function updateDescriptor(aInstallLocation, aOldAddon, aAddonState) {
|
|
logger.debug("Add-on " + aOldAddon.id + " moved to " + aAddonState.descriptor);
|
|
|
|
aOldAddon.descriptor = aAddonState.descriptor;
|
|
aOldAddon.visible = !(aOldAddon.id in visibleAddons);
|
|
XPIDatabase.saveChanges();
|
|
|
|
if (aOldAddon.visible) {
|
|
visibleAddons[aOldAddon.id] = aOldAddon;
|
|
|
|
if (aOldAddon.bootstrap && aOldAddon.active) {
|
|
let bootstrap = oldBootstrappedAddons[aOldAddon.id];
|
|
bootstrap.descriptor = aAddonState.descriptor;
|
|
XPIProvider.bootstrappedAddons[aOldAddon.id] = bootstrap;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Called when no change has been detected for an add-on's metadata. The
|
|
* add-on may have become visible due to other add-ons being removed or
|
|
* the add-on may need to be updated when the application version has
|
|
* changed.
|
|
*
|
|
* @param aInstallLocation
|
|
* The install location containing the add-on
|
|
* @param aOldAddon
|
|
* The AddonInternal as it appeared the last time the application
|
|
* ran
|
|
* @param aAddonState
|
|
* The new state of the add-on
|
|
* @return a boolean indicating if flushing caches is required to complete
|
|
* changing this add-on
|
|
*/
|
|
function updateVisibilityAndCompatibility(aInstallLocation, aOldAddon,
|
|
aAddonState) {
|
|
let changed = false;
|
|
|
|
// This add-ons metadata has not changed but it may have become visible
|
|
if (!(aOldAddon.id in visibleAddons)) {
|
|
visibleAddons[aOldAddon.id] = aOldAddon;
|
|
|
|
if (!aOldAddon.visible) {
|
|
// Remember add-ons that were changed during startup.
|
|
AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
|
|
aOldAddon.id);
|
|
XPIDatabase.makeAddonVisible(aOldAddon);
|
|
|
|
if (aOldAddon.bootstrap) {
|
|
// The add-on is bootstrappable so call its install script
|
|
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
|
|
file.persistentDescriptor = aAddonState.descriptor;
|
|
XPIProvider.callBootstrapMethod(aOldAddon, file,
|
|
"install",
|
|
BOOTSTRAP_REASONS.ADDON_INSTALL);
|
|
|
|
// If it should be active then mark it as active otherwise unload
|
|
// its scope
|
|
if (!aOldAddon.disabled) {
|
|
XPIDatabase.updateAddonActive(aOldAddon, true);
|
|
}
|
|
else {
|
|
XPIProvider.unloadBootstrapScope(newAddon.id);
|
|
}
|
|
}
|
|
else {
|
|
// Otherwise a restart is necessary
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// App version changed, we may need to update the appDisabled property.
|
|
if (aUpdateCompatibility) {
|
|
let wasDisabled = aOldAddon.disabled;
|
|
let wasAppDisabled = aOldAddon.appDisabled;
|
|
let wasUserDisabled = aOldAddon.userDisabled;
|
|
let wasSoftDisabled = aOldAddon.softDisabled;
|
|
|
|
// This updates the addon's JSON cached data in place
|
|
applyBlocklistChanges(aOldAddon, aOldAddon, aOldAppVersion,
|
|
aOldPlatformVersion);
|
|
aOldAddon.appDisabled = !isUsableAddon(aOldAddon);
|
|
|
|
let isDisabled = aOldAddon.disabled;
|
|
|
|
// If either property has changed update the database.
|
|
if (wasAppDisabled != aOldAddon.appDisabled ||
|
|
wasUserDisabled != aOldAddon.userDisabled ||
|
|
wasSoftDisabled != aOldAddon.softDisabled) {
|
|
logger.debug("Add-on " + aOldAddon.id + " changed appDisabled state to " +
|
|
aOldAddon.appDisabled + ", userDisabled state to " +
|
|
aOldAddon.userDisabled + " and softDisabled state to " +
|
|
aOldAddon.softDisabled);
|
|
XPIDatabase.saveChanges();
|
|
}
|
|
|
|
// If this is a visible add-on and it has changed disabled state then we
|
|
// may need a restart or to update the bootstrap list.
|
|
if (aOldAddon.visible && wasDisabled != isDisabled) {
|
|
// Remember add-ons that became disabled or enabled by the application
|
|
// change
|
|
let change = isDisabled ? AddonManager.STARTUP_CHANGE_DISABLED
|
|
: AddonManager.STARTUP_CHANGE_ENABLED;
|
|
AddonManagerPrivate.addStartupChange(change, aOldAddon.id);
|
|
if (aOldAddon.bootstrap) {
|
|
// Update the add-ons active state
|
|
XPIDatabase.updateAddonActive(aOldAddon, !isDisabled);
|
|
}
|
|
else {
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aOldAddon.visible && aOldAddon.active && aOldAddon.bootstrap) {
|
|
XPIProvider.bootstrappedAddons[aOldAddon.id] = {
|
|
version: aOldAddon.version,
|
|
type: aOldAddon.type,
|
|
descriptor: aAddonState.descriptor,
|
|
multiprocessCompatible: aOldAddon.multiprocessCompatible
|
|
};
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
/**
|
|
* Called when an add-on has been removed.
|
|
*
|
|
* @param aOldAddon
|
|
* The AddonInternal as it appeared the last time the application
|
|
* ran
|
|
* @return a boolean indicating if flushing caches is required to complete
|
|
* changing this add-on
|
|
*/
|
|
function removeMetadata(aOldAddon) {
|
|
// This add-on has disappeared
|
|
logger.debug("Add-on " + aOldAddon.id + " removed from " + aOldAddon.location);
|
|
XPIDatabase.removeAddonMetadata(aOldAddon);
|
|
|
|
// Remember add-ons that were uninstalled during startup
|
|
if (aOldAddon.visible) {
|
|
AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_UNINSTALLED,
|
|
aOldAddon.id);
|
|
}
|
|
else if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_INSTALLED)
|
|
.indexOf(aOldAddon.id) != -1) {
|
|
AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
|
|
aOldAddon.id);
|
|
}
|
|
|
|
if (aOldAddon.active) {
|
|
// Enable the default theme if the previously active theme has been
|
|
// removed
|
|
if (aOldAddon.type == "theme")
|
|
XPIProvider.enableDefaultTheme();
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Called to add the metadata for an add-on in one of the install locations
|
|
* to the database. This can be called in three different cases. Either an
|
|
* add-on has been dropped into the location from outside of Firefox, or
|
|
* an add-on has been installed through the application, or the database
|
|
* has been upgraded or become corrupt and add-on data has to be reloaded
|
|
* into it.
|
|
*
|
|
* @param aInstallLocation
|
|
* The install location containing the add-on
|
|
* @param aId
|
|
* The ID of the add-on
|
|
* @param aAddonState
|
|
* The new state of the add-on
|
|
* @param aMigrateData
|
|
* If during startup the database had to be upgraded this will
|
|
* contain data that used to be held about this add-on
|
|
* @return a boolean indicating if flushing caches is required to complete
|
|
* changing this add-on
|
|
*/
|
|
function addMetadata(aInstallLocation, aId, aAddonState, aMigrateData) {
|
|
logger.debug("New add-on " + aId + " installed in " + aInstallLocation.name);
|
|
|
|
let newAddon = null;
|
|
let sameVersion = false;
|
|
// Check the updated manifests lists for the install location, If there
|
|
// is no manifest for the add-on ID then newAddon will be undefined
|
|
if (aInstallLocation.name in aManifests)
|
|
newAddon = aManifests[aInstallLocation.name][aId];
|
|
|
|
// If we had staged data for this add-on or we aren't recovering from a
|
|
// corrupt database and we don't have migration data for this add-on then
|
|
// this must be a new install.
|
|
let isNewInstall = (!!newAddon) || (!XPIDatabase.activeBundles && !aMigrateData);
|
|
|
|
// If it's a new install and we haven't yet loaded the manifest then it
|
|
// must be something dropped directly into the install location
|
|
let isDetectedInstall = isNewInstall && !newAddon;
|
|
|
|
// Load the manifest if necessary and sanity check the add-on ID
|
|
try {
|
|
if (!newAddon) {
|
|
// Load the manifest from the add-on.
|
|
let file = aInstallLocation.getLocationForID(aId);
|
|
newAddon = loadManifestFromFile(file);
|
|
}
|
|
// The add-on in the manifest should match the add-on ID.
|
|
if (newAddon.id != aId) {
|
|
throw new Error("Invalid addon ID: expected addon ID " + aId +
|
|
", found " + newAddon.id + " in manifest");
|
|
}
|
|
}
|
|
catch (e) {
|
|
logger.warn("addMetadata: Add-on " + aId + " is invalid", e);
|
|
|
|
// Remove the invalid add-on from the install location if the install
|
|
// location isn't locked, no restart will be necessary
|
|
if (!aInstallLocation.locked)
|
|
aInstallLocation.uninstallAddon(aId);
|
|
else
|
|
logger.warn("Could not uninstall invalid item from locked install location");
|
|
return false;
|
|
}
|
|
|
|
// Update the AddonInternal properties.
|
|
newAddon._installLocation = aInstallLocation;
|
|
newAddon.visible = !(newAddon.id in visibleAddons);
|
|
newAddon.installDate = aAddonState.mtime;
|
|
newAddon.updateDate = aAddonState.mtime;
|
|
newAddon.foreignInstall = isDetectedInstall;
|
|
|
|
if (aMigrateData) {
|
|
// If there is migration data then apply it.
|
|
logger.debug("Migrating data from old database");
|
|
|
|
DB_MIGRATE_METADATA.forEach(function(aProp) {
|
|
// A theme's disabled state is determined by the selected theme
|
|
// preference which is read in loadManifestFromRDF
|
|
if (aProp == "userDisabled" && newAddon.type == "theme")
|
|
return;
|
|
|
|
if (aProp in aMigrateData)
|
|
newAddon[aProp] = aMigrateData[aProp];
|
|
});
|
|
|
|
// Force all non-profile add-ons to be foreignInstalls since they can't
|
|
// have been installed through the API
|
|
newAddon.foreignInstall |= aInstallLocation.name != KEY_APP_PROFILE;
|
|
|
|
// Some properties should only be migrated if the add-on hasn't changed.
|
|
// The version property isn't a perfect check for this but covers the
|
|
// vast majority of cases.
|
|
if (aMigrateData.version == newAddon.version) {
|
|
logger.debug("Migrating compatibility info");
|
|
sameVersion = true;
|
|
if ("targetApplications" in aMigrateData)
|
|
newAddon.applyCompatibilityUpdate(aMigrateData, true);
|
|
}
|
|
|
|
// Since the DB schema has changed make sure softDisabled is correct
|
|
applyBlocklistChanges(newAddon, newAddon, aOldAppVersion,
|
|
aOldPlatformVersion);
|
|
}
|
|
|
|
// The default theme is never a foreign install
|
|
if (newAddon.type == "theme" && newAddon.internalName == XPIProvider.defaultSkin)
|
|
newAddon.foreignInstall = false;
|
|
|
|
if (isDetectedInstall && newAddon.foreignInstall) {
|
|
// If the add-on is a foreign install and is in a scope where add-ons
|
|
// that were dropped in should default to disabled then disable it
|
|
let disablingScopes = Preferences.get(PREF_EM_AUTO_DISABLED_SCOPES, 0);
|
|
if (aInstallLocation.scope & disablingScopes) {
|
|
logger.warn("Disabling foreign installed add-on " + newAddon.id + " in "
|
|
+ aInstallLocation.name);
|
|
newAddon.userDisabled = true;
|
|
}
|
|
}
|
|
|
|
// If we have a list of what add-ons should be marked as active then use
|
|
// it to guess at migration data.
|
|
if (!isNewInstall && XPIDatabase.activeBundles) {
|
|
// For themes we know which is active by the current skin setting
|
|
if (newAddon.type == "theme")
|
|
newAddon.active = newAddon.internalName == XPIProvider.currentSkin;
|
|
else
|
|
newAddon.active = XPIDatabase.activeBundles.indexOf(aAddonState.descriptor) != -1;
|
|
|
|
// If the add-on wasn't active and it isn't already disabled in some way
|
|
// then it was probably either softDisabled or userDisabled
|
|
if (!newAddon.active && newAddon.visible && !newAddon.disabled) {
|
|
// If the add-on is softblocked then assume it is softDisabled
|
|
if (newAddon.blocklistState == Blocklist.STATE_SOFTBLOCKED)
|
|
newAddon.softDisabled = true;
|
|
else
|
|
newAddon.userDisabled = true;
|
|
}
|
|
}
|
|
else {
|
|
newAddon.active = (newAddon.visible && !newAddon.disabled);
|
|
}
|
|
|
|
let newDBAddon = XPIDatabase.addAddonMetadata(newAddon, aAddonState.descriptor);
|
|
|
|
if (newDBAddon.visible) {
|
|
// Remember add-ons that were first detected during startup.
|
|
if (isDetectedInstall) {
|
|
// If a copy from a higher priority location was removed then this
|
|
// add-on has changed
|
|
if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_UNINSTALLED)
|
|
.indexOf(newDBAddon.id) != -1) {
|
|
AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
|
|
newDBAddon.id);
|
|
}
|
|
else {
|
|
AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_INSTALLED,
|
|
newDBAddon.id);
|
|
}
|
|
}
|
|
|
|
// Note if any visible add-on is not in the application install location
|
|
if (newDBAddon._installLocation.name != KEY_APP_GLOBAL)
|
|
XPIProvider.allAppGlobal = false;
|
|
|
|
visibleAddons[newDBAddon.id] = newDBAddon;
|
|
|
|
let installReason = BOOTSTRAP_REASONS.ADDON_INSTALL;
|
|
let extraParams = {};
|
|
|
|
// Copy add-on details (enabled, bootstrap, version, etc) to XPIState.
|
|
aAddonState.syncWithDB(newDBAddon);
|
|
|
|
// If we're hiding a bootstrapped add-on then call its uninstall method
|
|
if (newDBAddon.id in oldBootstrappedAddons) {
|
|
let oldBootstrap = oldBootstrappedAddons[newDBAddon.id];
|
|
extraParams.oldVersion = oldBootstrap.version;
|
|
XPIProvider.bootstrappedAddons[newDBAddon.id] = oldBootstrap;
|
|
|
|
// If the old version is the same as the new version, or we're
|
|
// recovering from a corrupt DB, don't call uninstall and install
|
|
// methods.
|
|
if (sameVersion || !isNewInstall) {
|
|
logger.debug("addMetadata: early return, sameVersion " + sameVersion
|
|
+ ", isNewInstall " + isNewInstall);
|
|
return false;
|
|
}
|
|
|
|
installReason = Services.vc.compare(oldBootstrap.version, newDBAddon.version) < 0 ?
|
|
BOOTSTRAP_REASONS.ADDON_UPGRADE :
|
|
BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
|
|
|
|
let oldAddonFile = Cc["@mozilla.org/file/local;1"].
|
|
createInstance(Ci.nsIFile);
|
|
oldAddonFile.persistentDescriptor = oldBootstrap.descriptor;
|
|
|
|
XPIProvider.callBootstrapMethod(createAddonDetails(newDBAddon.id, oldBootstrap),
|
|
oldAddonFile, "uninstall", installReason,
|
|
{ newVersion: newDBAddon.version });
|
|
|
|
XPIProvider.unloadBootstrapScope(newDBAddon.id);
|
|
|
|
// If the new add-on is bootstrapped then we must flush the caches
|
|
// before calling the new bootstrap script
|
|
if (newDBAddon.bootstrap)
|
|
flushChromeCaches();
|
|
}
|
|
|
|
if (!newDBAddon.bootstrap)
|
|
return true;
|
|
|
|
// Visible bootstrapped add-ons need to have their install method called
|
|
let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile);
|
|
file.persistentDescriptor = aAddonState.descriptor;
|
|
XPIProvider.callBootstrapMethod(newDBAddon, file,
|
|
"install", installReason, extraParams);
|
|
if (!newDBAddon.active)
|
|
XPIProvider.unloadBootstrapScope(newDBAddon.id);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
let changed = false;
|
|
|
|
// Get all the add-ons in the existing DB and Map them into Sets by install location
|
|
let allDBAddons = new Map();
|
|
for (let a of XPIDatabase.getAddons()) {
|
|
let locationSet = allDBAddons.get(a.location);
|
|
if (!locationSet) {
|
|
locationSet = new Set();
|
|
allDBAddons.set(a.location, locationSet);
|
|
}
|
|
locationSet.add(a);
|
|
}
|
|
|
|
for (let installLocation of this.installLocations) {
|
|
// Get all the on-disk XPI states for this location, and keep track of which
|
|
// ones we see in the database.
|
|
let states = XPIStates.getLocation(installLocation.name);
|
|
let seen = new Set();
|
|
// Iterate through the add-ons installed the last time the application
|
|
// ran
|
|
let dbAddons = allDBAddons.get(installLocation.name);
|
|
if (dbAddons) {
|
|
// we've processed this location
|
|
allDBAddons.delete(installLocation.name);
|
|
|
|
logger.debug("processFileChanges reconciling DB for location ${l} state ${s} db ${d}",
|
|
{l: installLocation.name, s: states, d: [for (a of dbAddons) a.id]});
|
|
for (let aOldAddon of dbAddons) {
|
|
// If a version of this add-on has been installed in an higher
|
|
// priority install location then count it as changed
|
|
if (AddonManager.getStartupChanges(AddonManager.STARTUP_CHANGE_INSTALLED)
|
|
.indexOf(aOldAddon.id) != -1) {
|
|
AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED,
|
|
aOldAddon.id);
|
|
}
|
|
|
|
// Check if the add-on is still installed
|
|
let xpiState = states && states.get(aOldAddon.id);
|
|
if (xpiState) {
|
|
// in this block, the add-on is in both XPIStates and the DB
|
|
seen.add(xpiState);
|
|
|
|
// The add-on has changed if the modification time has changed, or
|
|
// we have an updated manifest for it. Also reload the metadata for
|
|
// add-ons in the application directory when the application version
|
|
// has changed
|
|
if (aOldAddon.id in aManifests[installLocation.name] ||
|
|
aOldAddon.updateDate != xpiState.mtime ||
|
|
(aUpdateCompatibility && installLocation.name == KEY_APP_GLOBAL)) {
|
|
changed = updateMetadata(installLocation, aOldAddon, xpiState) ||
|
|
changed;
|
|
}
|
|
else if (aOldAddon.descriptor != xpiState.descriptor) {
|
|
changed = updateDescriptor(installLocation, aOldAddon, xpiState) ||
|
|
changed;
|
|
}
|
|
else {
|
|
changed = updateMetadata(installLocation, aOldAddon, xpiState) ||
|
|
changed;
|
|
|
|
changed = updateVisibilityAndCompatibility(installLocation,
|
|
aOldAddon, xpiState) ||
|
|
changed;
|
|
}
|
|
if (aOldAddon.visible && aOldAddon._installLocation.name != KEY_APP_GLOBAL)
|
|
XPIProvider.allAppGlobal = false;
|
|
// Copy add-on details (enabled, bootstrap, version, etc) to XPIState.
|
|
xpiState.syncWithDB(aOldAddon);
|
|
}
|
|
else {
|
|
// The add-on is in the DB, but not in xpiState (and thus not on disk).
|
|
changed = removeMetadata(aOldAddon) || changed;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Any add-on in our current location that we haven't seen needs to
|
|
// be added to the database.
|
|
// Get the migration data for this install location so we can include that as
|
|
// we add, in case this is a database upgrade or rebuild.
|
|
let locMigrateData = {};
|
|
if (XPIDatabase.migrateData && installLocation.name in XPIDatabase.migrateData)
|
|
locMigrateData = XPIDatabase.migrateData[installLocation.name];
|
|
if (states) {
|
|
for (let [id, xpiState] of states) {
|
|
if (!seen.has(xpiState)) {
|
|
changed = addMetadata(installLocation, id, xpiState,
|
|
(locMigrateData[id] || null)) || changed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Anything left in allDBAddons is a location where the database contains add-ons,
|
|
// but the browser is no longer configured to use that location. The metadata for those
|
|
// add-ons must be removed from the database.
|
|
for (let [locationName, addons] of allDBAddons) {
|
|
logger.debug("Removing orphaned DB add-on entries from " + locationName);
|
|
for (let a of addons) {
|
|
logger.debug("Remove ${location}:${id}", a);
|
|
changed = removeMetadata(a) || changed;
|
|
}
|
|
}
|
|
|
|
XPIStates.save();
|
|
this.persistBootstrappedAddons();
|
|
|
|
// Clear out any cached migration data.
|
|
XPIDatabase.migrateData = null;
|
|
|
|
return changed;
|
|
},
|
|
|
|
/**
|
|
* Imports the xpinstall permissions from preferences into the permissions
|
|
* manager for the user to change later.
|
|
*/
|
|
importPermissions: function XPI_importPermissions() {
|
|
PermissionsUtils.importFromPrefs(PREF_XPI_PERMISSIONS_BRANCH,
|
|
XPI_PERMISSION);
|
|
},
|
|
|
|
/**
|
|
* Checks for any changes that have occurred since the last time the
|
|
* application was launched.
|
|
*
|
|
* @param aAppChanged
|
|
* A tri-state value. Undefined means the current profile was created
|
|
* for this session, true means the profile already existed but was
|
|
* last used with an application with a different version number,
|
|
* false means that the profile was last used by this version of the
|
|
* application.
|
|
* @param aOldAppVersion
|
|
* The version of the application last run with this profile or null
|
|
* if it is a new profile or the version is unknown
|
|
* @param aOldPlatformVersion
|
|
* The version of the platform last run with this profile or null
|
|
* if it is a new profile or the version is unknown
|
|
* @return true if a change requiring a restart was detected
|
|
*/
|
|
checkForChanges: function XPI_checkForChanges(aAppChanged, aOldAppVersion,
|
|
aOldPlatformVersion) {
|
|
logger.debug("checkForChanges");
|
|
|
|
// Keep track of whether and why we need to open and update the database at
|
|
// startup time.
|
|
let updateReasons = [];
|
|
if (aAppChanged) {
|
|
updateReasons.push("appChanged");
|
|
}
|
|
|
|
// Load the list of bootstrapped add-ons first so processFileChanges can
|
|
// modify it
|
|
// XXX eventually get rid of bootstrappedAddons
|
|
try {
|
|
this.bootstrappedAddons = JSON.parse(Preferences.get(PREF_BOOTSTRAP_ADDONS,
|
|
"{}"));
|
|
} catch (e) {
|
|
logger.warn("Error parsing enabled bootstrapped extensions cache", e);
|
|
}
|
|
|
|
// First install any new add-ons into the locations, if there are any
|
|
// changes then we must update the database with the information in the
|
|
// install locations
|
|
let manifests = {};
|
|
let updated = this.processPendingFileChanges(manifests);
|
|
if (updated) {
|
|
updateReasons.push("pendingFileChanges");
|
|
}
|
|
|
|
// This will be true if the previous session made changes that affect the
|
|
// active state of add-ons but didn't commit them properly (normally due
|
|
// to the application crashing)
|
|
let hasPendingChanges = Preferences.get(PREF_PENDING_OPERATIONS);
|
|
if (hasPendingChanges) {
|
|
updateReasons.push("hasPendingChanges");
|
|
}
|
|
|
|
// If the application has changed then check for new distribution add-ons
|
|
if (aAppChanged !== false &&
|
|
Preferences.get(PREF_INSTALL_DISTRO_ADDONS, true))
|
|
{
|
|
updated = this.installDistributionAddons(manifests);
|
|
if (updated) {
|
|
updateReasons.push("installDistributionAddons");
|
|
}
|
|
}
|
|
|
|
// Telemetry probe added around getInstallState() to check perf
|
|
let telemetryCaptureTime = Cu.now();
|
|
let installChanged = XPIStates.getInstallState();
|
|
let telemetry = Services.telemetry;
|
|
telemetry.getHistogramById("CHECK_ADDONS_MODIFIED_MS").add(Math.round(Cu.now() - telemetryCaptureTime));
|
|
if (installChanged) {
|
|
updateReasons.push("directoryState");
|
|
}
|
|
|
|
let haveAnyAddons = (XPIStates.size > 0);
|
|
|
|
// If the schema appears to have changed then we should update the database
|
|
if (DB_SCHEMA != Preferences.get(PREF_DB_SCHEMA, 0)) {
|
|
// If we don't have any add-ons, just update the pref, since we don't need to
|
|
// write the database
|
|
if (!haveAnyAddons) {
|
|
logger.debug("Empty XPI database, setting schema version preference to " + DB_SCHEMA);
|
|
Services.prefs.setIntPref(PREF_DB_SCHEMA, DB_SCHEMA);
|
|
}
|
|
else {
|
|
updateReasons.push("schemaChanged");
|
|
}
|
|
}
|
|
|
|
// If the database doesn't exist and there are add-ons installed then we
|
|
// must update the database however if there are no add-ons then there is
|
|
// no need to update the database.
|
|
let dbFile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_DATABASE], true);
|
|
if (!dbFile.exists() && haveAnyAddons) {
|
|
updateReasons.push("needNewDatabase");
|
|
}
|
|
|
|
// XXX This will go away when we fold bootstrappedAddons into XPIStates.
|
|
if (updateReasons.length == 0) {
|
|
let bootstrapDescriptors = new Set([for (b of Object.keys(this.bootstrappedAddons))
|
|
this.bootstrappedAddons[b].descriptor]);
|
|
|
|
for (let location of XPIStates.db.values()) {
|
|
for (let state of location.values()) {
|
|
bootstrapDescriptors.delete(state.descriptor);
|
|
}
|
|
}
|
|
|
|
if (bootstrapDescriptors.size > 0) {
|
|
logger.warn("Bootstrap state is invalid (missing add-ons: "
|
|
+ [for (b of bootstrapDescriptors) b] + ")");
|
|
updateReasons.push("missingBootstrapAddon");
|
|
}
|
|
}
|
|
|
|
// Catch and log any errors during the main startup
|
|
try {
|
|
let extensionListChanged = false;
|
|
// If the database needs to be updated then open it and then update it
|
|
// from the filesystem
|
|
if (updateReasons.length > 0) {
|
|
AddonManagerPrivate.recordSimpleMeasure("XPIDB_startup_load_reasons", updateReasons);
|
|
XPIDatabase.syncLoadDB(false);
|
|
try {
|
|
extensionListChanged = this.processFileChanges(manifests,
|
|
aAppChanged,
|
|
aOldAppVersion,
|
|
aOldPlatformVersion);
|
|
}
|
|
catch (e) {
|
|
logger.error("Failed to process extension changes at startup", e);
|
|
}
|
|
}
|
|
|
|
if (aAppChanged) {
|
|
// When upgrading the app and using a custom skin make sure it is still
|
|
// compatible otherwise switch back the default
|
|
if (this.currentSkin != this.defaultSkin) {
|
|
let oldSkin = XPIDatabase.getVisibleAddonForInternalName(this.currentSkin);
|
|
if (!oldSkin || oldSkin.disabled)
|
|
this.enableDefaultTheme();
|
|
}
|
|
|
|
// When upgrading remove the old extensions cache to force older
|
|
// versions to rescan the entire list of extensions
|
|
try {
|
|
let oldCache = FileUtils.getFile(KEY_PROFILEDIR, [FILE_OLD_CACHE], true);
|
|
if (oldCache.exists())
|
|
oldCache.remove(true);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Unable to remove old extension cache " + oldCache.path, e);
|
|
}
|
|
}
|
|
|
|
// If the application crashed before completing any pending operations then
|
|
// we should perform them now.
|
|
if (extensionListChanged || hasPendingChanges) {
|
|
logger.debug("Updating database with changes to installed add-ons");
|
|
XPIDatabase.updateActiveAddons();
|
|
Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS,
|
|
!XPIDatabase.writeAddonsList());
|
|
Services.prefs.setCharPref(PREF_BOOTSTRAP_ADDONS,
|
|
JSON.stringify(this.bootstrappedAddons));
|
|
return true;
|
|
}
|
|
|
|
logger.debug("No changes found");
|
|
}
|
|
catch (e) {
|
|
logger.error("Error during startup file checks", e);
|
|
}
|
|
|
|
// Check that the add-ons list still exists
|
|
let addonsList = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST],
|
|
true);
|
|
// the addons list file should exist if and only if we have add-ons installed
|
|
if (addonsList.exists() != haveAnyAddons) {
|
|
logger.debug("Add-ons list is invalid, rebuilding");
|
|
XPIDatabase.writeAddonsList();
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Called to test whether this provider supports installing a particular
|
|
* mimetype.
|
|
*
|
|
* @param aMimetype
|
|
* The mimetype to check for
|
|
* @return true if the mimetype is application/x-xpinstall
|
|
*/
|
|
supportsMimetype: function XPI_supportsMimetype(aMimetype) {
|
|
return aMimetype == "application/x-xpinstall";
|
|
},
|
|
|
|
/**
|
|
* Called to test whether installing XPI add-ons is enabled.
|
|
*
|
|
* @return true if installing is enabled
|
|
*/
|
|
isInstallEnabled: function XPI_isInstallEnabled() {
|
|
// Default to enabled if the preference does not exist
|
|
return Preferences.get(PREF_XPI_ENABLED, true);
|
|
},
|
|
|
|
/**
|
|
* Called to test whether installing XPI add-ons by direct URL requests is
|
|
* whitelisted.
|
|
*
|
|
* @return true if installing by direct requests is whitelisted
|
|
*/
|
|
isDirectRequestWhitelisted: function XPI_isDirectRequestWhitelisted() {
|
|
// Default to whitelisted if the preference does not exist.
|
|
return Preferences.get(PREF_XPI_DIRECT_WHITELISTED, true);
|
|
},
|
|
|
|
/**
|
|
* Called to test whether installing XPI add-ons from file referrers is
|
|
* whitelisted.
|
|
*
|
|
* @return true if installing from file referrers is whitelisted
|
|
*/
|
|
isFileRequestWhitelisted: function XPI_isFileRequestWhitelisted() {
|
|
// Default to whitelisted if the preference does not exist.
|
|
return Preferences.get(PREF_XPI_FILE_WHITELISTED, true);
|
|
},
|
|
|
|
/**
|
|
* Called to test whether installing XPI add-ons from a URI is allowed.
|
|
*
|
|
* @param aInstallingPrincipal
|
|
* The nsIPrincipal that initiated the install
|
|
* @return true if installing is allowed
|
|
*/
|
|
isInstallAllowed: function XPI_isInstallAllowed(aInstallingPrincipal) {
|
|
if (!this.isInstallEnabled())
|
|
return false;
|
|
|
|
let uri = aInstallingPrincipal.URI;
|
|
|
|
// Direct requests without a referrer are either whitelisted or blocked.
|
|
if (!uri)
|
|
return this.isDirectRequestWhitelisted();
|
|
|
|
// Local referrers can be whitelisted.
|
|
if (this.isFileRequestWhitelisted() &&
|
|
(uri.schemeIs("chrome") || uri.schemeIs("file")))
|
|
return true;
|
|
|
|
this.importPermissions();
|
|
|
|
let permission = Services.perms.testPermissionFromPrincipal(aInstallingPrincipal, XPI_PERMISSION);
|
|
if (permission == Ci.nsIPermissionManager.DENY_ACTION)
|
|
return false;
|
|
|
|
let requireWhitelist = Preferences.get(PREF_XPI_WHITELIST_REQUIRED, true);
|
|
if (requireWhitelist && (permission != Ci.nsIPermissionManager.ALLOW_ACTION))
|
|
return false;
|
|
|
|
let requireSecureOrigin = Preferences.get(PREF_INSTALL_REQUIRESECUREORIGIN, true);
|
|
let safeSchemes = ["https", "chrome", "file"];
|
|
if (requireSecureOrigin && safeSchemes.indexOf(uri.scheme) == -1)
|
|
return false;
|
|
|
|
return true;
|
|
},
|
|
|
|
/**
|
|
* Called to get an AddonInstall to download and install an add-on from a URL.
|
|
*
|
|
* @param aUrl
|
|
* The URL to be installed
|
|
* @param aHash
|
|
* A hash for the install
|
|
* @param aName
|
|
* A name for the install
|
|
* @param aIcons
|
|
* Icon URLs for the install
|
|
* @param aVersion
|
|
* A version for the install
|
|
* @param aBrowser
|
|
* The browser performing the install
|
|
* @param aCallback
|
|
* A callback to pass the AddonInstall to
|
|
*/
|
|
getInstallForURL: function XPI_getInstallForURL(aUrl, aHash, aName, aIcons,
|
|
aVersion, aBrowser, aCallback) {
|
|
AddonInstall.createDownload(function getInstallForURL_createDownload(aInstall) {
|
|
aCallback(aInstall.wrapper);
|
|
}, aUrl, aHash, aName, aIcons, aVersion, aBrowser);
|
|
},
|
|
|
|
/**
|
|
* Called to get an AddonInstall to install an add-on from a local file.
|
|
*
|
|
* @param aFile
|
|
* The file to be installed
|
|
* @param aCallback
|
|
* A callback to pass the AddonInstall to
|
|
*/
|
|
getInstallForFile: function XPI_getInstallForFile(aFile, aCallback) {
|
|
AddonInstall.createInstall(function getInstallForFile_createInstall(aInstall) {
|
|
if (aInstall)
|
|
aCallback(aInstall.wrapper);
|
|
else
|
|
aCallback(null);
|
|
}, aFile);
|
|
},
|
|
|
|
/**
|
|
* Removes an AddonInstall from the list of active installs.
|
|
*
|
|
* @param install
|
|
* The AddonInstall to remove
|
|
*/
|
|
removeActiveInstall: function XPI_removeActiveInstall(aInstall) {
|
|
let where = this.installs.indexOf(aInstall);
|
|
if (where == -1) {
|
|
logger.warn("removeActiveInstall: could not find active install for "
|
|
+ aInstall.sourceURI.spec);
|
|
return;
|
|
}
|
|
this.installs.splice(where, 1);
|
|
},
|
|
|
|
/**
|
|
* Called to get an Addon with a particular ID.
|
|
*
|
|
* @param aId
|
|
* The ID of the add-on to retrieve
|
|
* @param aCallback
|
|
* A callback to pass the Addon to
|
|
*/
|
|
getAddonByID: function XPI_getAddonByID(aId, aCallback) {
|
|
XPIDatabase.getVisibleAddonForID (aId, function getAddonByID_getVisibleAddonForID(aAddon) {
|
|
aCallback(createWrapper(aAddon));
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Called to get Addons of a particular type.
|
|
*
|
|
* @param aTypes
|
|
* An array of types to fetch. Can be null to get all types.
|
|
* @param aCallback
|
|
* A callback to pass an array of Addons to
|
|
*/
|
|
getAddonsByTypes: function XPI_getAddonsByTypes(aTypes, aCallback) {
|
|
XPIDatabase.getVisibleAddons(aTypes, function getAddonsByTypes_getVisibleAddons(aAddons) {
|
|
// Tycho: aCallback([createWrapper(a) for each (a in aAddons)]);
|
|
let result = [];
|
|
for each(let a in aAddons) {
|
|
result.push(createWrapper(a));
|
|
}
|
|
aCallback(result);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Obtain an Addon having the specified Sync GUID.
|
|
*
|
|
* @param aGUID
|
|
* String GUID of add-on to retrieve
|
|
* @param aCallback
|
|
* A callback to pass the Addon to. Receives null if not found.
|
|
*/
|
|
getAddonBySyncGUID: function XPI_getAddonBySyncGUID(aGUID, aCallback) {
|
|
XPIDatabase.getAddonBySyncGUID(aGUID, function getAddonBySyncGUID_getAddonBySyncGUID(aAddon) {
|
|
aCallback(createWrapper(aAddon));
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Called to get Addons that have pending operations.
|
|
*
|
|
* @param aTypes
|
|
* An array of types to fetch. Can be null to get all types
|
|
* @param aCallback
|
|
* A callback to pass an array of Addons to
|
|
*/
|
|
getAddonsWithOperationsByTypes:
|
|
function XPI_getAddonsWithOperationsByTypes(aTypes, aCallback) {
|
|
XPIDatabase.getVisibleAddonsWithPendingOperations(aTypes,
|
|
function getAddonsWithOpsByTypes_getVisibleAddonsWithPendingOps(aAddons) {
|
|
// Tycho: let results = [createWrapper(a) for each (a in aAddons)];
|
|
let results = [];
|
|
for each(let a in aAddons) {
|
|
results.push(createWrapper(a));
|
|
}
|
|
|
|
XPIProvider.installs.forEach(function(aInstall) {
|
|
if (aInstall.state == AddonManager.STATE_INSTALLED &&
|
|
!(aInstall.addon.inDatabase))
|
|
results.push(createWrapper(aInstall.addon));
|
|
});
|
|
aCallback(results);
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Called to get the current AddonInstalls, optionally limiting to a list of
|
|
* types.
|
|
*
|
|
* @param aTypes
|
|
* An array of types or null to get all types
|
|
* @param aCallback
|
|
* A callback to pass the array of AddonInstalls to
|
|
*/
|
|
getInstallsByTypes: function XPI_getInstallsByTypes(aTypes, aCallback) {
|
|
let results = [];
|
|
this.installs.forEach(function(aInstall) {
|
|
if (!aTypes || aTypes.indexOf(aInstall.type) >= 0)
|
|
results.push(aInstall.wrapper);
|
|
});
|
|
aCallback(results);
|
|
},
|
|
|
|
/**
|
|
* Synchronously map a URI to the corresponding Addon ID.
|
|
*
|
|
* Mappable URIs are limited to in-application resources belonging to the
|
|
* add-on, such as Javascript compartments, XUL windows, XBL bindings, etc.
|
|
* but do not include URIs from meta data, such as the add-on homepage.
|
|
*
|
|
* @param aURI
|
|
* nsIURI to map or null
|
|
* @return string containing the Addon ID
|
|
* @see AddonManager.mapURIToAddonID
|
|
* @see amIAddonManager.mapURIToAddonID
|
|
*/
|
|
mapURIToAddonID: function XPI_mapURIToAddonID(aURI) {
|
|
// Returns `null` instead of empty string if the URI can't be mapped.
|
|
return AddonPathService.mapURIToAddonId(aURI) || null;
|
|
},
|
|
|
|
/**
|
|
* Called when a new add-on has been enabled when only one add-on of that type
|
|
* can be enabled.
|
|
*
|
|
* @param aId
|
|
* The ID of the newly enabled add-on
|
|
* @param aType
|
|
* The type of the newly enabled add-on
|
|
* @param aPendingRestart
|
|
* true if the newly enabled add-on will only become enabled after a
|
|
* restart
|
|
*/
|
|
addonChanged: function XPI_addonChanged(aId, aType, aPendingRestart) {
|
|
// We only care about themes in this provider
|
|
if (aType != "theme")
|
|
return;
|
|
|
|
if (!aId) {
|
|
// Fallback to the default theme when no theme was enabled
|
|
this.enableDefaultTheme();
|
|
return;
|
|
}
|
|
|
|
// Look for the previously enabled theme and find the internalName of the
|
|
// currently selected theme
|
|
let previousTheme = null;
|
|
let newSkin = this.defaultSkin;
|
|
let addons = XPIDatabase.getAddonsByType("theme");
|
|
addons.forEach(function(aTheme) {
|
|
if (!aTheme.visible)
|
|
return;
|
|
if (aTheme.id == aId)
|
|
newSkin = aTheme.internalName;
|
|
else if (aTheme.userDisabled == false && !aTheme.pendingUninstall)
|
|
previousTheme = aTheme;
|
|
}, this);
|
|
|
|
if (aPendingRestart) {
|
|
Services.prefs.setBoolPref(PREF_DSS_SWITCHPENDING, true);
|
|
Services.prefs.setCharPref(PREF_DSS_SKIN_TO_SELECT, newSkin);
|
|
}
|
|
else if (newSkin == this.currentSkin) {
|
|
try {
|
|
Services.prefs.clearUserPref(PREF_DSS_SWITCHPENDING);
|
|
}
|
|
catch (e) { }
|
|
try {
|
|
Services.prefs.clearUserPref(PREF_DSS_SKIN_TO_SELECT);
|
|
}
|
|
catch (e) { }
|
|
}
|
|
else {
|
|
Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN, newSkin);
|
|
this.currentSkin = newSkin;
|
|
}
|
|
this.selectedSkin = newSkin;
|
|
|
|
// Flush the preferences to disk so they don't get out of sync with the
|
|
// database
|
|
Services.prefs.savePrefFile(null);
|
|
|
|
// Mark the previous theme as disabled. This won't cause recursion since
|
|
// only enabled calls notifyAddonChanged.
|
|
if (previousTheme)
|
|
this.updateAddonDisabledState(previousTheme, true);
|
|
},
|
|
|
|
/**
|
|
* Update the appDisabled property for all add-ons.
|
|
*/
|
|
updateAddonAppDisabledStates: function XPI_updateAddonAppDisabledStates() {
|
|
let addons = XPIDatabase.getAddons();
|
|
addons.forEach(function(aAddon) {
|
|
this.updateAddonDisabledState(aAddon);
|
|
}, this);
|
|
},
|
|
|
|
/**
|
|
* Update the repositoryAddon property for all add-ons.
|
|
*
|
|
* @param aCallback
|
|
* Function to call when operation is complete.
|
|
*/
|
|
updateAddonRepositoryData: function XPI_updateAddonRepositoryData(aCallback) {
|
|
let self = this;
|
|
XPIDatabase.getVisibleAddons(null, function UARD_getVisibleAddonsCallback(aAddons) {
|
|
let pending = aAddons.length;
|
|
logger.debug("updateAddonRepositoryData found " + pending + " visible add-ons");
|
|
if (pending == 0) {
|
|
aCallback();
|
|
return;
|
|
}
|
|
|
|
function notifyComplete() {
|
|
if (--pending == 0)
|
|
aCallback();
|
|
}
|
|
|
|
for (let addon of aAddons) {
|
|
AddonRepository.getCachedAddonByID(addon.id,
|
|
function UARD_getCachedAddonCallback(aRepoAddon) {
|
|
if (aRepoAddon) {
|
|
logger.debug("updateAddonRepositoryData got info for " + addon.id);
|
|
addon._repositoryAddon = aRepoAddon;
|
|
addon.compatibilityOverrides = aRepoAddon.compatibilityOverrides;
|
|
self.updateAddonDisabledState(addon);
|
|
}
|
|
|
|
notifyComplete();
|
|
});
|
|
};
|
|
});
|
|
},
|
|
|
|
/**
|
|
* When the previously selected theme is removed this method will be called
|
|
* to enable the default theme.
|
|
*/
|
|
enableDefaultTheme: function XPI_enableDefaultTheme() {
|
|
logger.debug("Activating default theme");
|
|
let addon = XPIDatabase.getVisibleAddonForInternalName(this.defaultSkin);
|
|
if (addon) {
|
|
if (addon.userDisabled) {
|
|
this.updateAddonDisabledState(addon, false);
|
|
}
|
|
else if (!this.extensionsActive) {
|
|
// During startup we may end up trying to enable the default theme when
|
|
// the database thinks it is already enabled (see f.e. bug 638847). In
|
|
// this case just force the theme preferences to be correct
|
|
Services.prefs.setCharPref(PREF_GENERAL_SKINS_SELECTEDSKIN,
|
|
addon.internalName);
|
|
this.currentSkin = this.selectedSkin = addon.internalName;
|
|
Preferences.reset(PREF_DSS_SKIN_TO_SELECT);
|
|
Preferences.reset(PREF_DSS_SWITCHPENDING);
|
|
}
|
|
else {
|
|
logger.warn("Attempting to activate an already active default theme");
|
|
}
|
|
}
|
|
else {
|
|
logger.warn("Unable to activate the default theme");
|
|
}
|
|
},
|
|
|
|
onDebugConnectionChange: function(aEvent, aWhat, aConnection) {
|
|
if (aWhat != "opened")
|
|
return;
|
|
|
|
for (let id of Object.keys(this.bootstrapScopes)) {
|
|
aConnection.setAddonOptions(id, { global: this.bootstrapScopes[id] });
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Notified when a preference we're interested in has changed.
|
|
*
|
|
* @see nsIObserver
|
|
*/
|
|
observe: function XPI_observe(aSubject, aTopic, aData) {
|
|
if (aTopic == NOTIFICATION_FLUSH_PERMISSIONS) {
|
|
if (!aData || aData == XPI_PERMISSION) {
|
|
this.importPermissions();
|
|
}
|
|
return;
|
|
}
|
|
#ifdef MOZ_DEVTOOLS
|
|
else if (aTopic == NOTIFICATION_TOOLBOXPROCESS_LOADED) {
|
|
Services.obs.removeObserver(this, NOTIFICATION_TOOLBOXPROCESS_LOADED, false);
|
|
this._toolboxProcessLoaded = true;
|
|
BrowserToolboxProcess.on("connectionchange",
|
|
this.onDebugConnectionChange.bind(this));
|
|
}
|
|
#endif
|
|
|
|
if (aTopic == "nsPref:changed") {
|
|
switch (aData) {
|
|
case PREF_EM_MIN_COMPAT_APP_VERSION:
|
|
case PREF_EM_MIN_COMPAT_PLATFORM_VERSION:
|
|
this.minCompatibleAppVersion = Preferences.get(PREF_EM_MIN_COMPAT_APP_VERSION,
|
|
null);
|
|
this.minCompatiblePlatformVersion = Preferences.get(PREF_EM_MIN_COMPAT_PLATFORM_VERSION,
|
|
null);
|
|
this.updateAddonAppDisabledStates();
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Tests whether enabling an add-on will require a restart.
|
|
*
|
|
* @param aAddon
|
|
* The add-on to test
|
|
* @return true if the operation requires a restart
|
|
*/
|
|
enableRequiresRestart: function XPI_enableRequiresRestart(aAddon) {
|
|
// If the platform couldn't have activated extensions then we can make
|
|
// changes without any restart.
|
|
if (!this.extensionsActive)
|
|
return false;
|
|
|
|
// If the application is in safe mode then any change can be made without
|
|
// restarting
|
|
if (Services.appinfo.inSafeMode)
|
|
return false;
|
|
|
|
// Anything that is active is already enabled
|
|
if (aAddon.active)
|
|
return false;
|
|
|
|
if (aAddon.type == "theme") {
|
|
// If dynamic theme switching is enabled then switching themes does not
|
|
// require a restart
|
|
if (Preferences.get(PREF_EM_DSS_ENABLED))
|
|
return false;
|
|
|
|
// If the theme is already the theme in use then no restart is necessary.
|
|
// This covers the case where the default theme is in use but a
|
|
// lightweight theme is considered active.
|
|
return aAddon.internalName != this.currentSkin;
|
|
}
|
|
|
|
return !aAddon.bootstrap;
|
|
},
|
|
|
|
/**
|
|
* Tests whether disabling an add-on will require a restart.
|
|
*
|
|
* @param aAddon
|
|
* The add-on to test
|
|
* @return true if the operation requires a restart
|
|
*/
|
|
disableRequiresRestart: function XPI_disableRequiresRestart(aAddon) {
|
|
// If the platform couldn't have activated up extensions then we can make
|
|
// changes without any restart.
|
|
if (!this.extensionsActive)
|
|
return false;
|
|
|
|
// If the application is in safe mode then any change can be made without
|
|
// restarting
|
|
if (Services.appinfo.inSafeMode)
|
|
return false;
|
|
|
|
// Anything that isn't active is already disabled
|
|
if (!aAddon.active)
|
|
return false;
|
|
|
|
if (aAddon.type == "theme") {
|
|
// If dynamic theme switching is enabled then switching themes does not
|
|
// require a restart
|
|
if (Preferences.get(PREF_EM_DSS_ENABLED))
|
|
return false;
|
|
|
|
// Non-default themes always require a restart to disable since it will
|
|
// be switching from one theme to another or to the default theme and a
|
|
// lightweight theme.
|
|
if (aAddon.internalName != this.defaultSkin)
|
|
return true;
|
|
|
|
// The default theme requires a restart to disable if we are in the
|
|
// process of switching to a different theme. Note that this makes the
|
|
// disabled flag of operationsRequiringRestart incorrect for the default
|
|
// theme (it will be false most of the time). Bug 520124 would be required
|
|
// to fix it. For the UI this isn't a problem since we never try to
|
|
// disable or uninstall the default theme.
|
|
return this.selectedSkin != this.currentSkin;
|
|
}
|
|
|
|
return !aAddon.bootstrap;
|
|
},
|
|
|
|
/**
|
|
* Tests whether installing an add-on will require a restart.
|
|
*
|
|
* @param aAddon
|
|
* The add-on to test
|
|
* @return true if the operation requires a restart
|
|
*/
|
|
installRequiresRestart: function XPI_installRequiresRestart(aAddon) {
|
|
// If the platform couldn't have activated up extensions then we can make
|
|
// changes without any restart.
|
|
if (!this.extensionsActive)
|
|
return false;
|
|
|
|
// If the application is in safe mode then any change can be made without
|
|
// restarting
|
|
if (Services.appinfo.inSafeMode)
|
|
return false;
|
|
|
|
// Add-ons that are already installed don't require a restart to install.
|
|
// This wouldn't normally be called for an already installed add-on (except
|
|
// for forming the operationsRequiringRestart flags) so is really here as
|
|
// a safety measure.
|
|
if (aAddon.inDatabase)
|
|
return false;
|
|
|
|
// If we have an AddonInstall for this add-on then we can see if there is
|
|
// an existing installed add-on with the same ID
|
|
if ("_install" in aAddon && aAddon._install) {
|
|
// If there is an existing installed add-on and uninstalling it would
|
|
// require a restart then installing the update will also require a
|
|
// restart
|
|
let existingAddon = aAddon._install.existingAddon;
|
|
if (existingAddon && this.uninstallRequiresRestart(existingAddon))
|
|
return true;
|
|
}
|
|
|
|
// If the add-on is not going to be active after installation then it
|
|
// doesn't require a restart to install.
|
|
if (aAddon.disabled)
|
|
return false;
|
|
|
|
// Themes will require a restart (even if dynamic switching is enabled due
|
|
// to some caching issues) and non-bootstrapped add-ons will require a
|
|
// restart
|
|
return aAddon.type == "theme" || !aAddon.bootstrap;
|
|
},
|
|
|
|
/**
|
|
* Tests whether uninstalling an add-on will require a restart.
|
|
*
|
|
* @param aAddon
|
|
* The add-on to test
|
|
* @return true if the operation requires a restart
|
|
*/
|
|
uninstallRequiresRestart: function XPI_uninstallRequiresRestart(aAddon) {
|
|
// If the platform couldn't have activated up extensions then we can make
|
|
// changes without any restart.
|
|
if (!this.extensionsActive)
|
|
return false;
|
|
|
|
// If the application is in safe mode then any change can be made without
|
|
// restarting
|
|
if (Services.appinfo.inSafeMode)
|
|
return false;
|
|
|
|
// If the add-on can be disabled without a restart then it can also be
|
|
// uninstalled without a restart
|
|
return this.disableRequiresRestart(aAddon);
|
|
},
|
|
|
|
/**
|
|
* Loads a bootstrapped add-on's bootstrap.js into a sandbox and the reason
|
|
* values as constants in the scope. This will also add information about the
|
|
* add-on to the bootstrappedAddons dictionary and notify the crash reporter
|
|
* that new add-ons have been loaded.
|
|
*
|
|
* @param aId
|
|
* The add-on's ID
|
|
* @param aFile
|
|
* The nsIFile for the add-on
|
|
* @param aVersion
|
|
* The add-on's version
|
|
* @param aType
|
|
* The type for the add-on
|
|
* @param aMultiprocessCompatible
|
|
* Boolean indicating whether the add-on is compatible with electrolysis.
|
|
* @return a JavaScript scope
|
|
*/
|
|
loadBootstrapScope: function XPI_loadBootstrapScope(aId, aFile, aVersion, aType,
|
|
aMultiprocessCompatible) {
|
|
// Mark the add-on as active for the crash reporter before loading
|
|
this.bootstrappedAddons[aId] = {
|
|
version: aVersion,
|
|
type: aType,
|
|
descriptor: aFile.persistentDescriptor,
|
|
multiprocessCompatible: aMultiprocessCompatible
|
|
};
|
|
this.persistBootstrappedAddons();
|
|
this.addAddonsToCrashReporter();
|
|
|
|
// Locales only contain chrome and can't have bootstrap scripts
|
|
if (aType == "locale") {
|
|
this.bootstrapScopes[aId] = null;
|
|
return;
|
|
}
|
|
|
|
logger.debug("Loading bootstrap scope from " + aFile.path);
|
|
|
|
let principal = Cc["@mozilla.org/systemprincipal;1"].
|
|
createInstance(Ci.nsIPrincipal);
|
|
if (!aMultiprocessCompatible && Preferences.get(PREF_INTERPOSITION_ENABLED, false)) {
|
|
let interposition = Cc["@mozilla.org/addons/multiprocess-shims;1"].
|
|
getService(Ci.nsIAddonInterposition);
|
|
Cu.setAddonInterposition(aId, interposition);
|
|
}
|
|
|
|
if (!aFile.exists()) {
|
|
this.bootstrapScopes[aId] =
|
|
new Cu.Sandbox(principal, { sandboxName: aFile.path,
|
|
wantGlobalProperties: ["indexedDB"],
|
|
addonId: aId,
|
|
metadata: { addonID: aId } });
|
|
logger.error("Attempted to load bootstrap scope from missing directory " + aFile.path);
|
|
return;
|
|
}
|
|
|
|
let uri = getURIForResourceInFile(aFile, "bootstrap.js").spec;
|
|
if (aType == "dictionary")
|
|
uri = "resource://gre/modules/addons/SpellCheckDictionaryBootstrap.js"
|
|
|
|
this.bootstrapScopes[aId] =
|
|
new Cu.Sandbox(principal, { sandboxName: uri,
|
|
wantGlobalProperties: ["indexedDB"],
|
|
addonId: aId,
|
|
metadata: { addonID: aId, URI: uri } });
|
|
|
|
let loader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
|
|
createInstance(Ci.mozIJSSubScriptLoader);
|
|
|
|
try {
|
|
// Copy the reason values from the global object into the bootstrap scope.
|
|
for (let name in BOOTSTRAP_REASONS)
|
|
this.bootstrapScopes[aId][name] = BOOTSTRAP_REASONS[name];
|
|
|
|
// Add other stuff that extensions want.
|
|
const features = [ "Worker", "ChromeWorker" ];
|
|
|
|
for (let feature of features)
|
|
this.bootstrapScopes[aId][feature] = gGlobalScope[feature];
|
|
|
|
// Define a console for the add-on
|
|
this.bootstrapScopes[aId]["console"] = new ConsoleAPI({ consoleID: "addon/" + aId });
|
|
|
|
// As we don't want our caller to control the JS version used for the
|
|
// bootstrap file, we run loadSubScript within the context of the
|
|
// sandbox with the latest JS version set explicitly.
|
|
this.bootstrapScopes[aId].__SCRIPT_URI_SPEC__ = uri;
|
|
Components.utils.evalInSandbox(
|
|
"Components.classes['@mozilla.org/moz/jssubscript-loader;1'] \
|
|
.createInstance(Components.interfaces.mozIJSSubScriptLoader) \
|
|
.loadSubScript(__SCRIPT_URI_SPEC__);", this.bootstrapScopes[aId], "ECMAv5");
|
|
}
|
|
catch (e) {
|
|
logger.warn("Error loading bootstrap.js for " + aId, e);
|
|
}
|
|
|
|
#ifdef MOZ_DEVTOOLS
|
|
// Only access BrowserToolboxProcess if ToolboxProcess.jsm has been
|
|
// initialized as otherwise, when it will be initialized, all addons'
|
|
// globals will be added anyways
|
|
if (this._toolboxProcessLoaded) {
|
|
BrowserToolboxProcess.setAddonOptions(aId, { global: this.bootstrapScopes[aId] });
|
|
}
|
|
#endif
|
|
},
|
|
|
|
/**
|
|
* Unloads a bootstrap scope by dropping all references to it and then
|
|
* updating the list of active add-ons with the crash reporter.
|
|
*
|
|
* @param aId
|
|
* The add-on's ID
|
|
*/
|
|
unloadBootstrapScope: function XPI_unloadBootstrapScope(aId) {
|
|
// In case the add-on was not multiprocess-compatible, deregister
|
|
// any interpositions for it.
|
|
Cu.setAddonInterposition(aId, null);
|
|
|
|
delete this.bootstrapScopes[aId];
|
|
delete this.bootstrappedAddons[aId];
|
|
this.persistBootstrappedAddons();
|
|
this.addAddonsToCrashReporter();
|
|
|
|
#ifdef MOZ_DEVTOOLS
|
|
// Only access BrowserToolboxProcess if ToolboxProcess.jsm has been
|
|
// initialized as otherwise, there won't be any addon globals added to it
|
|
if (this._toolboxProcessLoaded) {
|
|
BrowserToolboxProcess.setAddonOptions(aId, { global: null });
|
|
}
|
|
#endif
|
|
},
|
|
|
|
/**
|
|
* Calls a bootstrap method for an add-on.
|
|
*
|
|
* @param aAddon
|
|
* An object representing the add-on, with `id`, `type` and `version`
|
|
* @param aFile
|
|
* The nsIFile for the add-on
|
|
* @param aMethod
|
|
* The name of the bootstrap method to call
|
|
* @param aReason
|
|
* The reason flag to pass to the bootstrap's startup method
|
|
* @param aExtraParams
|
|
* An object of additional key/value pairs to pass to the method in
|
|
* the params argument
|
|
*/
|
|
callBootstrapMethod: function XPI_callBootstrapMethod(aAddon, aFile, aMethod, aReason, aExtraParams) {
|
|
// Never call any bootstrap methods in safe mode
|
|
if (Services.appinfo.inSafeMode)
|
|
return;
|
|
|
|
if (!aAddon.id || !aAddon.version || !aAddon.type) {
|
|
logger.error(new Error("aAddon must include an id, version, and type"));
|
|
return;
|
|
}
|
|
|
|
let timeStart = new Date();
|
|
if (aMethod == "startup") {
|
|
logger.debug("Registering manifest for " + aFile.path);
|
|
Components.manager.addBootstrappedManifestLocation(aFile);
|
|
}
|
|
|
|
try {
|
|
// Load the scope if it hasn't already been loaded
|
|
if (!(aAddon.id in this.bootstrapScopes))
|
|
this.loadBootstrapScope(aAddon.id, aFile, aAddon.version, aAddon.type,
|
|
aAddon.multiprocessCompatible || false);
|
|
|
|
// Nothing to call for locales
|
|
if (aAddon.type == "locale")
|
|
return;
|
|
|
|
let method = undefined;
|
|
try {
|
|
method = Components.utils.evalInSandbox(`${aMethod};`,
|
|
this.bootstrapScopes[aAddon.id],
|
|
"ECMAv5");
|
|
}
|
|
catch (e) {
|
|
// An exception will be caught if the expected method is not defined.
|
|
// That will be logged below.
|
|
}
|
|
|
|
if (!method) {
|
|
logger.warn("Add-on " + aAddon.id + " is missing bootstrap method " + aMethod);
|
|
return;
|
|
}
|
|
|
|
let params = {
|
|
id: aAddon.id,
|
|
version: aAddon.version,
|
|
installPath: aFile.clone(),
|
|
resourceURI: getURIForResourceInFile(aFile, "")
|
|
};
|
|
|
|
if (aExtraParams) {
|
|
for (let key in aExtraParams) {
|
|
params[key] = aExtraParams[key];
|
|
}
|
|
}
|
|
|
|
logger.debug("Calling bootstrap method " + aMethod + " on " + aAddon.id + " version " +
|
|
aAddon.version);
|
|
try {
|
|
method(params, aReason);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Exception running bootstrap method " + aMethod + " on " + aAddon.id, e);
|
|
}
|
|
}
|
|
finally {
|
|
if (aMethod == "shutdown" && aReason != BOOTSTRAP_REASONS.APP_SHUTDOWN) {
|
|
logger.debug("Removing manifest for " + aFile.path);
|
|
Components.manager.removeBootstrappedManifestLocation(aFile);
|
|
|
|
let manifest = getURIForResourceInFile(aFile, "chrome.manifest");
|
|
for (let line of ChromeManifestParser.parseSync(manifest)) {
|
|
if (line.type == "resource") {
|
|
ResProtocolHandler.setSubstitution(line.args[0], null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Updates the disabled state for an add-on. Its appDisabled property will be
|
|
* calculated and if the add-on is changed the database will be saved and
|
|
* appropriate notifications will be sent out to the registered AddonListeners.
|
|
*
|
|
* @param aAddon
|
|
* The DBAddonInternal to update
|
|
* @param aUserDisabled
|
|
* Value for the userDisabled property. If undefined the value will
|
|
* not change
|
|
* @param aSoftDisabled
|
|
* Value for the softDisabled property. If undefined the value will
|
|
* not change. If true this will force userDisabled to be true
|
|
* @throws if addon is not a DBAddonInternal
|
|
*/
|
|
updateAddonDisabledState: function XPI_updateAddonDisabledState(aAddon,
|
|
aUserDisabled,
|
|
aSoftDisabled) {
|
|
if (!(aAddon.inDatabase))
|
|
throw new Error("Can only update addon states for installed addons.");
|
|
if (aUserDisabled !== undefined && aSoftDisabled !== undefined) {
|
|
throw new Error("Cannot change userDisabled and softDisabled at the " +
|
|
"same time");
|
|
}
|
|
|
|
if (aUserDisabled === undefined) {
|
|
aUserDisabled = aAddon.userDisabled;
|
|
}
|
|
else if (!aUserDisabled) {
|
|
// If enabling the add-on then remove softDisabled
|
|
aSoftDisabled = false;
|
|
}
|
|
|
|
// If not changing softDisabled or the add-on is already userDisabled then
|
|
// use the existing value for softDisabled
|
|
if (aSoftDisabled === undefined || aUserDisabled)
|
|
aSoftDisabled = aAddon.softDisabled;
|
|
|
|
let appDisabled = !isUsableAddon(aAddon);
|
|
// No change means nothing to do here
|
|
if (aAddon.userDisabled == aUserDisabled &&
|
|
aAddon.appDisabled == appDisabled &&
|
|
aAddon.softDisabled == aSoftDisabled)
|
|
return;
|
|
|
|
let wasDisabled = aAddon.disabled;
|
|
let isDisabled = aUserDisabled || aSoftDisabled || appDisabled;
|
|
|
|
// If appDisabled changes but addon.disabled doesn't,
|
|
// no onDisabling/onEnabling is sent - so send a onPropertyChanged.
|
|
let appDisabledChanged = aAddon.appDisabled != appDisabled;
|
|
|
|
// Update the properties in the database.
|
|
// We never persist this for experiments because the disabled flags
|
|
// are controlled by the Experiments Manager.
|
|
if (aAddon.type != "experiment") {
|
|
XPIDatabase.setAddonProperties(aAddon, {
|
|
userDisabled: aUserDisabled,
|
|
appDisabled: appDisabled,
|
|
softDisabled: aSoftDisabled
|
|
});
|
|
}
|
|
|
|
if (appDisabledChanged) {
|
|
AddonManagerPrivate.callAddonListeners("onPropertyChanged",
|
|
aAddon,
|
|
["appDisabled"]);
|
|
}
|
|
|
|
// If the add-on is not visible or the add-on is not changing state then
|
|
// there is no need to do anything else
|
|
if (!aAddon.visible || (wasDisabled == isDisabled))
|
|
return;
|
|
|
|
// Flag that active states in the database need to be updated on shutdown
|
|
Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
|
|
|
|
let wrapper = createWrapper(aAddon);
|
|
// Have we just gone back to the current state?
|
|
if (isDisabled != aAddon.active) {
|
|
AddonManagerPrivate.callAddonListeners("onOperationCancelled", wrapper);
|
|
}
|
|
else {
|
|
if (isDisabled) {
|
|
var needsRestart = this.disableRequiresRestart(aAddon);
|
|
AddonManagerPrivate.callAddonListeners("onDisabling", wrapper,
|
|
needsRestart);
|
|
}
|
|
else {
|
|
needsRestart = this.enableRequiresRestart(aAddon);
|
|
AddonManagerPrivate.callAddonListeners("onEnabling", wrapper,
|
|
needsRestart);
|
|
}
|
|
|
|
if (!needsRestart) {
|
|
XPIDatabase.updateAddonActive(aAddon, !isDisabled);
|
|
if (isDisabled) {
|
|
if (aAddon.bootstrap) {
|
|
let file = aAddon._installLocation.getLocationForID(aAddon.id);
|
|
this.callBootstrapMethod(aAddon, file, "shutdown",
|
|
BOOTSTRAP_REASONS.ADDON_DISABLE);
|
|
this.unloadBootstrapScope(aAddon.id);
|
|
}
|
|
AddonManagerPrivate.callAddonListeners("onDisabled", wrapper);
|
|
}
|
|
else {
|
|
if (aAddon.bootstrap) {
|
|
let file = aAddon._installLocation.getLocationForID(aAddon.id);
|
|
this.callBootstrapMethod(aAddon, file, "startup",
|
|
BOOTSTRAP_REASONS.ADDON_ENABLE);
|
|
}
|
|
AddonManagerPrivate.callAddonListeners("onEnabled", wrapper);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sync with XPIStates.
|
|
let xpiState = XPIStates.getAddon(aAddon.location, aAddon.id);
|
|
if (xpiState) {
|
|
xpiState.syncWithDB(aAddon);
|
|
XPIStates.save();
|
|
} else {
|
|
// There should always be an xpiState
|
|
logger.warn("No XPIState for ${id} in ${location}", aAddon);
|
|
}
|
|
|
|
// Notify any other providers that a new theme has been enabled
|
|
if (aAddon.type == "theme" && !isDisabled)
|
|
AddonManagerPrivate.notifyAddonChanged(aAddon.id, aAddon.type, needsRestart);
|
|
},
|
|
|
|
/**
|
|
* Uninstalls an add-on, immediately if possible or marks it as pending
|
|
* uninstall if not.
|
|
*
|
|
* @param aAddon
|
|
* The DBAddonInternal to uninstall
|
|
* @param aForcePending
|
|
* Force this addon into the pending uninstall state, even if
|
|
* it isn't marked as requiring a restart (used e.g. while the
|
|
* add-on manager is open and offering an "undo" button)
|
|
* @throws if the addon cannot be uninstalled because it is in an install
|
|
* location that does not allow it
|
|
*/
|
|
uninstallAddon: function XPI_uninstallAddon(aAddon, aForcePending) {
|
|
if (!(aAddon.inDatabase))
|
|
throw new Error("Cannot uninstall addon " + aAddon.id + " because it is not installed");
|
|
|
|
if (aAddon._installLocation.locked)
|
|
throw new Error("Cannot uninstall addon " + aAddon.id
|
|
+ " from locked install location " + aAddon._installLocation.name);
|
|
|
|
// Inactive add-ons don't require a restart to uninstall
|
|
let requiresRestart = this.uninstallRequiresRestart(aAddon);
|
|
|
|
// if makePending is true, we don't actually apply the uninstall,
|
|
// we just mark the addon as having a pending uninstall
|
|
let makePending = aForcePending || requiresRestart;
|
|
|
|
if (makePending && aAddon.pendingUninstall)
|
|
throw new Error("Add-on is already marked to be uninstalled");
|
|
|
|
if ("_hasResourceCache" in aAddon)
|
|
aAddon._hasResourceCache = new Map();
|
|
|
|
if (aAddon._updateCheck) {
|
|
logger.debug("Cancel in-progress update check for " + aAddon.id);
|
|
aAddon._updateCheck.cancel();
|
|
}
|
|
|
|
let wasPending = aAddon.pendingUninstall;
|
|
|
|
if (makePending) {
|
|
// We create an empty directory in the staging directory to indicate
|
|
// that an uninstall is necessary on next startup.
|
|
let stage = aAddon._installLocation.getStagingDir();
|
|
stage.append(aAddon.id);
|
|
if (!stage.exists())
|
|
stage.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
|
|
|
|
XPIDatabase.setAddonProperties(aAddon, {
|
|
pendingUninstall: true
|
|
});
|
|
Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
|
|
let xpiState = XPIStates.getAddon(aAddon.location, aAddon.id);
|
|
if (xpiState) {
|
|
xpiState.enabled = false;
|
|
XPIStates.save();
|
|
} else {
|
|
logger.warn("Can't find XPI state while uninstalling ${id} from ${location}", aAddon);
|
|
}
|
|
}
|
|
|
|
// If the add-on is not visible then there is no need to notify listeners.
|
|
if (!aAddon.visible)
|
|
return;
|
|
|
|
let wrapper = createWrapper(aAddon);
|
|
|
|
// If the add-on wasn't already pending uninstall then notify listeners.
|
|
if (!wasPending) {
|
|
// Passing makePending as the requiresRestart parameter is a little
|
|
// strange as in some cases this operation can complete without a restart
|
|
// so really this is now saying that the uninstall isn't going to happen
|
|
// immediately but will happen later.
|
|
AddonManagerPrivate.callAddonListeners("onUninstalling", wrapper,
|
|
makePending);
|
|
}
|
|
|
|
// Reveal the highest priority add-on with the same ID
|
|
function revealAddon(aAddon) {
|
|
XPIDatabase.makeAddonVisible(aAddon);
|
|
|
|
let wrappedAddon = createWrapper(aAddon);
|
|
AddonManagerPrivate.callAddonListeners("onInstalling", wrappedAddon, false);
|
|
|
|
if (!aAddon.disabled && !XPIProvider.enableRequiresRestart(aAddon)) {
|
|
XPIDatabase.updateAddonActive(aAddon, true);
|
|
}
|
|
|
|
if (aAddon.bootstrap) {
|
|
let file = aAddon._installLocation.getLocationForID(aAddon.id);
|
|
XPIProvider.callBootstrapMethod(aAddon, file,
|
|
"install", BOOTSTRAP_REASONS.ADDON_INSTALL);
|
|
|
|
if (aAddon.active) {
|
|
XPIProvider.callBootstrapMethod(aAddon, file,
|
|
"startup", BOOTSTRAP_REASONS.ADDON_INSTALL);
|
|
}
|
|
else {
|
|
XPIProvider.unloadBootstrapScope(aAddon.id);
|
|
}
|
|
}
|
|
|
|
// We always send onInstalled even if a restart is required to enable
|
|
// the revealed add-on
|
|
AddonManagerPrivate.callAddonListeners("onInstalled", wrappedAddon);
|
|
}
|
|
|
|
function findAddonAndReveal(aId) {
|
|
let [locationName, ] = XPIStates.findAddon(aId);
|
|
if (locationName) {
|
|
XPIDatabase.getAddonInLocation(aId, locationName, revealAddon);
|
|
}
|
|
}
|
|
|
|
if (!makePending) {
|
|
if (aAddon.bootstrap) {
|
|
let file = aAddon._installLocation.getLocationForID(aAddon.id);
|
|
if (aAddon.active) {
|
|
this.callBootstrapMethod(aAddon, file, "shutdown",
|
|
BOOTSTRAP_REASONS.ADDON_UNINSTALL);
|
|
}
|
|
|
|
this.callBootstrapMethod(aAddon, file, "uninstall",
|
|
BOOTSTRAP_REASONS.ADDON_UNINSTALL);
|
|
this.unloadBootstrapScope(aAddon.id);
|
|
flushChromeCaches();
|
|
}
|
|
aAddon._installLocation.uninstallAddon(aAddon.id);
|
|
XPIDatabase.removeAddonMetadata(aAddon);
|
|
XPIStates.removeAddon(aAddon.location, aAddon.id);
|
|
AddonManagerPrivate.callAddonListeners("onUninstalled", wrapper);
|
|
|
|
findAddonAndReveal(aAddon.id);
|
|
}
|
|
else if (aAddon.bootstrap && aAddon.active && !this.disableRequiresRestart(aAddon)) {
|
|
this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "shutdown",
|
|
BOOTSTRAP_REASONS.ADDON_UNINSTALL);
|
|
this.unloadBootstrapScope(aAddon.id);
|
|
XPIDatabase.updateAddonActive(aAddon, false);
|
|
}
|
|
|
|
// Notify any other providers that a new theme has been enabled
|
|
if (aAddon.type == "theme" && aAddon.active)
|
|
AddonManagerPrivate.notifyAddonChanged(null, aAddon.type, requiresRestart);
|
|
},
|
|
|
|
/**
|
|
* Cancels the pending uninstall of an add-on.
|
|
*
|
|
* @param aAddon
|
|
* The DBAddonInternal to cancel uninstall for
|
|
*/
|
|
cancelUninstallAddon: function XPI_cancelUninstallAddon(aAddon) {
|
|
if (!(aAddon.inDatabase))
|
|
throw new Error("Can only cancel uninstall for installed addons.");
|
|
|
|
if (!aAddon.pendingUninstall)
|
|
throw new Error("Add-on is not marked to be uninstalled");
|
|
|
|
aAddon._installLocation.cleanStagingDir([aAddon.id]);
|
|
|
|
XPIDatabase.setAddonProperties(aAddon, {
|
|
pendingUninstall: false
|
|
});
|
|
|
|
if (!aAddon.visible)
|
|
return;
|
|
|
|
Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true);
|
|
|
|
// TODO hide hidden add-ons (bug 557710)
|
|
let wrapper = createWrapper(aAddon);
|
|
AddonManagerPrivate.callAddonListeners("onOperationCancelled", wrapper);
|
|
|
|
if (aAddon.bootstrap && !aAddon.disabled && !this.enableRequiresRestart(aAddon)) {
|
|
this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "startup",
|
|
BOOTSTRAP_REASONS.ADDON_INSTALL);
|
|
XPIDatabase.updateAddonActive(aAddon, true);
|
|
}
|
|
|
|
// Notify any other providers that this theme is now enabled again.
|
|
if (aAddon.type == "theme" && aAddon.active)
|
|
AddonManagerPrivate.notifyAddonChanged(aAddon.id, aAddon.type, false);
|
|
}
|
|
};
|
|
|
|
function getHashStringForCrypto(aCrypto) {
|
|
// return the two-digit hexadecimal code for a byte
|
|
let toHexString = charCode => ("0" + charCode.toString(16)).slice(-2);
|
|
|
|
// convert the binary hash data to a hex string.
|
|
let binary = aCrypto.finish(false);
|
|
let hash = Array.from(binary, c => toHexString(c.charCodeAt(0)))
|
|
return hash.join("").toLowerCase();
|
|
}
|
|
|
|
/**
|
|
* Instantiates an AddonInstall.
|
|
*
|
|
* @param aInstallLocation
|
|
* The install location the add-on will be installed into
|
|
* @param aUrl
|
|
* The nsIURL to get the add-on from. If this is an nsIFileURL then
|
|
* the add-on will not need to be downloaded
|
|
* @param aHash
|
|
* An optional hash for the add-on
|
|
* @param aReleaseNotesURI
|
|
* An optional nsIURI of release notes for the add-on
|
|
* @param aExistingAddon
|
|
* The add-on this install will update if known
|
|
* @param aBrowser
|
|
* The browser performing the install
|
|
* @throws if the url is the url of a local file and the hash does not match
|
|
* or the add-on does not contain an valid install manifest
|
|
*/
|
|
function AddonInstall(aInstallLocation, aUrl, aHash, aReleaseNotesURI,
|
|
aExistingAddon, aBrowser) {
|
|
this.wrapper = new AddonInstallWrapper(this);
|
|
this.installLocation = aInstallLocation;
|
|
this.sourceURI = aUrl;
|
|
this.releaseNotesURI = aReleaseNotesURI;
|
|
if (aHash) {
|
|
let hashSplit = aHash.toLowerCase().split(":");
|
|
this.originalHash = {
|
|
algorithm: hashSplit[0],
|
|
data: hashSplit[1]
|
|
};
|
|
}
|
|
this.hash = this.originalHash;
|
|
this.browser = aBrowser;
|
|
this.listeners = [];
|
|
this.icons = {};
|
|
this.existingAddon = aExistingAddon;
|
|
this.error = 0;
|
|
this.window = aBrowser ? aBrowser.contentWindow : null;
|
|
|
|
// Giving each instance of AddonInstall a reference to the logger.
|
|
this.logger = logger;
|
|
}
|
|
|
|
AddonInstall.prototype = {
|
|
installLocation: null,
|
|
wrapper: null,
|
|
stream: null,
|
|
crypto: null,
|
|
originalHash: null,
|
|
hash: null,
|
|
browser: null,
|
|
badCertHandler: null,
|
|
listeners: null,
|
|
restartDownload: false,
|
|
|
|
name: null,
|
|
type: null,
|
|
version: null,
|
|
icons: null,
|
|
releaseNotesURI: null,
|
|
sourceURI: null,
|
|
file: null,
|
|
ownsTempFile: false,
|
|
certificate: null,
|
|
certName: null,
|
|
|
|
linkedInstalls: null,
|
|
existingAddon: null,
|
|
addon: null,
|
|
|
|
state: null,
|
|
error: null,
|
|
progress: null,
|
|
maxProgress: null,
|
|
|
|
/**
|
|
* Initialises this install to be a staged install waiting to be applied
|
|
*
|
|
* @param aManifest
|
|
* The cached manifest for the staged install
|
|
*/
|
|
initStagedInstall: function AI_initStagedInstall(aManifest) {
|
|
this.name = aManifest.name;
|
|
this.type = aManifest.type;
|
|
this.version = aManifest.version;
|
|
this.icons = aManifest.icons;
|
|
this.releaseNotesURI = aManifest.releaseNotesURI ?
|
|
NetUtil.newURI(aManifest.releaseNotesURI) :
|
|
null
|
|
this.sourceURI = aManifest.sourceURI ?
|
|
NetUtil.newURI(aManifest.sourceURI) :
|
|
null;
|
|
this.file = null;
|
|
this.addon = aManifest;
|
|
|
|
this.state = AddonManager.STATE_INSTALLED;
|
|
|
|
XPIProvider.installs.push(this);
|
|
},
|
|
|
|
/**
|
|
* Initialises this install to be an install from a local file.
|
|
*
|
|
* @param aCallback
|
|
* The callback to pass the initialised AddonInstall to
|
|
*/
|
|
initLocalInstall: function AI_initLocalInstall(aCallback) {
|
|
aCallback = makeSafe(aCallback);
|
|
this.file = this.sourceURI.QueryInterface(Ci.nsIFileURL).file;
|
|
|
|
if (!this.file.exists()) {
|
|
logger.warn("XPI file " + this.file.path + " does not exist");
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
this.error = AddonManager.ERROR_NETWORK_FAILURE;
|
|
aCallback(this);
|
|
return;
|
|
}
|
|
|
|
this.state = AddonManager.STATE_DOWNLOADED;
|
|
this.progress = this.file.fileSize;
|
|
this.maxProgress = this.file.fileSize;
|
|
|
|
if (this.hash) {
|
|
let crypto = Cc["@mozilla.org/security/hash;1"].
|
|
createInstance(Ci.nsICryptoHash);
|
|
try {
|
|
crypto.initWithString(this.hash.algorithm);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Unknown hash algorithm '" + this.hash.algorithm + "' for addon " + this.sourceURI.spec, e);
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
this.error = AddonManager.ERROR_INCORRECT_HASH;
|
|
aCallback(this);
|
|
return;
|
|
}
|
|
|
|
let fis = Cc["@mozilla.org/network/file-input-stream;1"].
|
|
createInstance(Ci.nsIFileInputStream);
|
|
fis.init(this.file, -1, -1, false);
|
|
crypto.updateFromStream(fis, this.file.fileSize);
|
|
let calculatedHash = getHashStringForCrypto(crypto);
|
|
if (calculatedHash != this.hash.data) {
|
|
logger.warn("File hash (" + calculatedHash + ") did not match provided hash (" +
|
|
this.hash.data + ")");
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
this.error = AddonManager.ERROR_INCORRECT_HASH;
|
|
aCallback(this);
|
|
return;
|
|
}
|
|
}
|
|
|
|
try {
|
|
let self = this;
|
|
this.loadManifest(function initLocalInstall_loadManifest() {
|
|
XPIDatabase.getVisibleAddonForID(self.addon.id, function initLocalInstall_getVisibleAddon(aAddon) {
|
|
self.existingAddon = aAddon;
|
|
if (aAddon)
|
|
applyBlocklistChanges(aAddon, self.addon);
|
|
self.addon.updateDate = Date.now();
|
|
self.addon.installDate = aAddon ? aAddon.installDate : self.addon.updateDate;
|
|
|
|
if (!self.addon.isCompatible) {
|
|
// TODO Should we send some event here?
|
|
self.state = AddonManager.STATE_CHECKING;
|
|
new UpdateChecker(self.addon, {
|
|
onUpdateFinished: function updateChecker_onUpdateFinished(aAddon) {
|
|
self.state = AddonManager.STATE_DOWNLOADED;
|
|
XPIProvider.installs.push(self);
|
|
AddonManagerPrivate.callInstallListeners("onNewInstall",
|
|
self.listeners,
|
|
self.wrapper);
|
|
|
|
aCallback(self);
|
|
}
|
|
}, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);
|
|
}
|
|
else {
|
|
XPIProvider.installs.push(self);
|
|
AddonManagerPrivate.callInstallListeners("onNewInstall",
|
|
self.listeners,
|
|
self.wrapper);
|
|
|
|
aCallback(self);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
catch (e) {
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
if (e.webext) {
|
|
logger.warn("WebExtension XPI", e);
|
|
this.error = AddonManager.ERROR_WEBEXT_FILE;
|
|
#ifndef MOZ_JETPACK
|
|
} else if (e.jetpacksdk) {
|
|
logger.warn("Jetpack XPI", e);
|
|
this.error = AddonManager.ERROR_JETPACKSDK_FILE;
|
|
#endif
|
|
} else {
|
|
logger.warn("Invalid XPI", e);
|
|
this.error = AddonManager.ERROR_CORRUPT_FILE;
|
|
}
|
|
aCallback(this);
|
|
return;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Initialises this install to be a download from a remote url.
|
|
*
|
|
* @param aCallback
|
|
* The callback to pass the initialised AddonInstall to
|
|
* @param aName
|
|
* An optional name for the add-on
|
|
* @param aType
|
|
* An optional type for the add-on
|
|
* @param aIcons
|
|
* Optional icons for the add-on
|
|
* @param aVersion
|
|
* An optional version for the add-on
|
|
*/
|
|
initAvailableDownload: function AI_initAvailableDownload(aName, aType, aIcons, aVersion, aCallback) {
|
|
this.state = AddonManager.STATE_AVAILABLE;
|
|
this.name = aName;
|
|
this.type = aType;
|
|
this.version = aVersion;
|
|
this.icons = aIcons;
|
|
this.progress = 0;
|
|
this.maxProgress = -1;
|
|
|
|
XPIProvider.installs.push(this);
|
|
AddonManagerPrivate.callInstallListeners("onNewInstall", this.listeners,
|
|
this.wrapper);
|
|
|
|
makeSafe(aCallback)(this);
|
|
},
|
|
|
|
/**
|
|
* Starts installation of this add-on from whatever state it is currently at
|
|
* if possible.
|
|
*
|
|
* @throws if installation cannot proceed from the current state
|
|
*/
|
|
install: function AI_install() {
|
|
switch (this.state) {
|
|
case AddonManager.STATE_AVAILABLE:
|
|
this.startDownload();
|
|
break;
|
|
case AddonManager.STATE_DOWNLOADED:
|
|
this.startInstall();
|
|
break;
|
|
case AddonManager.STATE_DOWNLOAD_FAILED:
|
|
case AddonManager.STATE_INSTALL_FAILED:
|
|
case AddonManager.STATE_CANCELLED:
|
|
this.removeTemporaryFile();
|
|
this.state = AddonManager.STATE_AVAILABLE;
|
|
this.error = 0;
|
|
this.progress = 0;
|
|
this.maxProgress = -1;
|
|
this.hash = this.originalHash;
|
|
XPIProvider.installs.push(this);
|
|
this.startDownload();
|
|
break;
|
|
case AddonManager.STATE_DOWNLOADING:
|
|
case AddonManager.STATE_CHECKING:
|
|
case AddonManager.STATE_INSTALLING:
|
|
// Installation is already running
|
|
return;
|
|
default:
|
|
throw new Error("Cannot start installing from this state");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Cancels installation of this add-on.
|
|
*
|
|
* @throws if installation cannot be cancelled from the current state
|
|
*/
|
|
cancel: function AI_cancel() {
|
|
switch (this.state) {
|
|
case AddonManager.STATE_DOWNLOADING:
|
|
if (this.channel) {
|
|
logger.debug("Cancelling download of " + this.sourceURI.spec);
|
|
this.channel.cancel(Cr.NS_BINDING_ABORTED);
|
|
}
|
|
break;
|
|
case AddonManager.STATE_AVAILABLE:
|
|
case AddonManager.STATE_DOWNLOADED:
|
|
logger.debug("Cancelling download of " + this.sourceURI.spec);
|
|
this.state = AddonManager.STATE_CANCELLED;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
|
|
this.listeners, this.wrapper);
|
|
this.removeTemporaryFile();
|
|
break;
|
|
case AddonManager.STATE_INSTALLED:
|
|
logger.debug("Cancelling install of " + this.addon.id);
|
|
let xpi = this.installLocation.getStagingDir();
|
|
xpi.append(this.addon.id + ".xpi");
|
|
flushJarCache(xpi);
|
|
this.installLocation.cleanStagingDir([this.addon.id, this.addon.id + ".xpi",
|
|
this.addon.id + ".json"]);
|
|
this.state = AddonManager.STATE_CANCELLED;
|
|
XPIProvider.removeActiveInstall(this);
|
|
|
|
if (this.existingAddon) {
|
|
delete this.existingAddon.pendingUpgrade;
|
|
this.existingAddon.pendingUpgrade = null;
|
|
}
|
|
|
|
AddonManagerPrivate.callAddonListeners("onOperationCancelled", createWrapper(this.addon));
|
|
|
|
AddonManagerPrivate.callInstallListeners("onInstallCancelled",
|
|
this.listeners, this.wrapper);
|
|
break;
|
|
default:
|
|
throw new Error("Cannot cancel install of " + this.sourceURI.spec +
|
|
" from this state (" + this.state + ")");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Adds an InstallListener for this instance if the listener is not already
|
|
* registered.
|
|
*
|
|
* @param aListener
|
|
* The InstallListener to add
|
|
*/
|
|
addListener: function AI_addListener(aListener) {
|
|
if (!this.listeners.some(function addListener_matchListener(i) { return i == aListener; }))
|
|
this.listeners.push(aListener);
|
|
},
|
|
|
|
/**
|
|
* Removes an InstallListener for this instance if it is registered.
|
|
*
|
|
* @param aListener
|
|
* The InstallListener to remove
|
|
*/
|
|
removeListener: function AI_removeListener(aListener) {
|
|
this.listeners = this.listeners.filter(function removeListener_filterListener(i) {
|
|
return i != aListener;
|
|
});
|
|
},
|
|
|
|
/**
|
|
* Removes the temporary file owned by this AddonInstall if there is one.
|
|
*/
|
|
removeTemporaryFile: function AI_removeTemporaryFile() {
|
|
// Only proceed if this AddonInstall owns its XPI file
|
|
if (!this.ownsTempFile) {
|
|
this.logger.debug("removeTemporaryFile: " + this.sourceURI.spec + " does not own temp file");
|
|
return;
|
|
}
|
|
|
|
try {
|
|
this.logger.debug("removeTemporaryFile: " + this.sourceURI.spec + " removing temp file " +
|
|
this.file.path);
|
|
this.file.remove(true);
|
|
this.ownsTempFile = false;
|
|
}
|
|
catch (e) {
|
|
this.logger.warn("Failed to remove temporary file " + this.file.path + " for addon " +
|
|
this.sourceURI.spec,
|
|
e);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Updates the sourceURI and releaseNotesURI values on the Addon being
|
|
* installed by this AddonInstall instance.
|
|
*/
|
|
updateAddonURIs: function AI_updateAddonURIs() {
|
|
this.addon.sourceURI = this.sourceURI.spec;
|
|
if (this.releaseNotesURI)
|
|
this.addon.releaseNotesURI = this.releaseNotesURI.spec;
|
|
},
|
|
|
|
/**
|
|
* Loads add-on manifests from a multi-package XPI file. Each of the
|
|
* XPI and JAR files contained in the XPI will be extracted. Any that
|
|
* do not contain valid add-ons will be ignored. The first valid add-on will
|
|
* be installed by this AddonInstall instance, the rest will have new
|
|
* AddonInstall instances created for them.
|
|
*
|
|
* @param aZipReader
|
|
* An open nsIZipReader for the multi-package XPI's files. This will
|
|
* be closed before this method returns.
|
|
* @param aCallback
|
|
* A function to call when all of the add-on manifests have been
|
|
* loaded. Because this loadMultipackageManifests is an internal API
|
|
* we don't exception-wrap this callback
|
|
*/
|
|
_loadMultipackageManifests: function AI_loadMultipackageManifests(aZipReader,
|
|
aCallback) {
|
|
let files = [];
|
|
let entries = aZipReader.findEntries("(*.[Xx][Pp][Ii]|*.[Jj][Aa][Rr])");
|
|
while (entries.hasMore()) {
|
|
let entryName = entries.getNext();
|
|
var target = getTemporaryFile();
|
|
try {
|
|
aZipReader.extract(entryName, target);
|
|
files.push(target);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to extract " + entryName + " from multi-package " +
|
|
"XPI", e);
|
|
target.remove(false);
|
|
}
|
|
}
|
|
|
|
aZipReader.close();
|
|
|
|
if (files.length == 0) {
|
|
throw new Error("Multi-package XPI does not contain any packages " +
|
|
"to install");
|
|
}
|
|
|
|
let addon = null;
|
|
|
|
// Find the first file that has a valid install manifest and use it for
|
|
// the add-on that this AddonInstall instance will install.
|
|
while (files.length > 0) {
|
|
this.removeTemporaryFile();
|
|
this.file = files.shift();
|
|
this.ownsTempFile = true;
|
|
try {
|
|
addon = loadManifestFromZipFile(this.file);
|
|
break;
|
|
}
|
|
catch (e) {
|
|
logger.warn(this.file.leafName + " cannot be installed from multi-package " +
|
|
"XPI", e);
|
|
}
|
|
}
|
|
|
|
if (!addon) {
|
|
// No valid add-on was found
|
|
aCallback();
|
|
return;
|
|
}
|
|
|
|
this.addon = addon;
|
|
|
|
this.updateAddonURIs();
|
|
|
|
this.addon._install = this;
|
|
this.name = this.addon.selectedLocale.name || this.addon.defaultLocale.name;
|
|
this.type = this.addon.type;
|
|
this.version = this.addon.version;
|
|
|
|
// Setting the iconURL to something inside the XPI locks the XPI and
|
|
// makes it impossible to delete on Windows.
|
|
//let newIcon = createWrapper(this.addon).iconURL;
|
|
//if (newIcon)
|
|
// this.iconURL = newIcon;
|
|
|
|
// Create new AddonInstall instances for every remaining file
|
|
if (files.length > 0) {
|
|
this.linkedInstalls = [];
|
|
let count = 0;
|
|
let self = this;
|
|
files.forEach(function(file) {
|
|
AddonInstall.createInstall(function loadMultipackageManifests_createInstall(aInstall) {
|
|
// Ignore bad add-ons (createInstall will have logged the error)
|
|
if (aInstall.state == AddonManager.STATE_DOWNLOAD_FAILED) {
|
|
// Manually remove the temporary file
|
|
file.remove(true);
|
|
}
|
|
else {
|
|
// Make the new install own its temporary file
|
|
aInstall.ownsTempFile = true;
|
|
|
|
self.linkedInstalls.push(aInstall)
|
|
|
|
aInstall.sourceURI = self.sourceURI;
|
|
aInstall.releaseNotesURI = self.releaseNotesURI;
|
|
aInstall.updateAddonURIs();
|
|
}
|
|
|
|
count++;
|
|
if (count == files.length)
|
|
aCallback();
|
|
}, file);
|
|
}, this);
|
|
}
|
|
else {
|
|
aCallback();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called after the add-on is a local file and the signature and install
|
|
* manifest can be read.
|
|
*
|
|
* @param aCallback
|
|
* A function to call when the manifest has been loaded
|
|
* @throws if the add-on does not contain a valid install manifest or the
|
|
* XPI is incorrectly signed
|
|
*/
|
|
loadManifest: function AI_loadManifest(aCallback) {
|
|
aCallback = makeSafe(aCallback);
|
|
let self = this;
|
|
function addRepositoryData(aAddon) {
|
|
// Try to load from the existing cache first
|
|
AddonRepository.getCachedAddonByID(aAddon.id, function loadManifest_getCachedAddonByID(aRepoAddon) {
|
|
if (aRepoAddon) {
|
|
aAddon._repositoryAddon = aRepoAddon;
|
|
self.name = self.name || aAddon._repositoryAddon.name;
|
|
aAddon.compatibilityOverrides = aRepoAddon.compatibilityOverrides;
|
|
aAddon.appDisabled = !isUsableAddon(aAddon);
|
|
aCallback();
|
|
return;
|
|
}
|
|
|
|
// It wasn't there so try to re-download it
|
|
AddonRepository.cacheAddons([aAddon.id], function loadManifest_cacheAddons() {
|
|
AddonRepository.getCachedAddonByID(aAddon.id, function loadManifest_getCachedAddonByID(aRepoAddon) {
|
|
aAddon._repositoryAddon = aRepoAddon;
|
|
self.name = self.name || aAddon._repositoryAddon.name;
|
|
aAddon.compatibilityOverrides = aRepoAddon ?
|
|
aRepoAddon.compatibilityOverrides :
|
|
null;
|
|
aAddon.appDisabled = !isUsableAddon(aAddon);
|
|
aCallback();
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
let zipreader = Cc["@mozilla.org/libjar/zip-reader;1"].
|
|
createInstance(Ci.nsIZipReader);
|
|
try {
|
|
zipreader.open(this.file);
|
|
}
|
|
catch (e) {
|
|
zipreader.close();
|
|
throw e;
|
|
}
|
|
|
|
let x509 = zipreader.getSigningCert(null);
|
|
if (x509) {
|
|
logger.debug("Verifying XPI signature");
|
|
if (verifyZipSigning(zipreader, x509)) {
|
|
this.certificate = x509;
|
|
if (this.certificate.commonName.length > 0) {
|
|
this.certName = this.certificate.commonName;
|
|
} else {
|
|
this.certName = this.certificate.organization;
|
|
}
|
|
} else {
|
|
zipreader.close();
|
|
throw new Error("XPI is incorrectly signed");
|
|
}
|
|
}
|
|
|
|
try {
|
|
this.addon = loadManifestFromZipReader(zipreader);
|
|
}
|
|
catch (e) {
|
|
zipreader.close();
|
|
throw e;
|
|
}
|
|
|
|
if (this.addon.type == "multipackage") {
|
|
this._loadMultipackageManifests(zipreader, function loadManifest_loadMultipackageManifests() {
|
|
addRepositoryData(self.addon);
|
|
});
|
|
return;
|
|
}
|
|
|
|
zipreader.close();
|
|
|
|
this.updateAddonURIs();
|
|
|
|
this.addon._install = this;
|
|
this.name = this.addon.selectedLocale.name || this.addon.defaultLocale.name;
|
|
this.type = this.addon.type;
|
|
this.version = this.addon.version;
|
|
|
|
// Setting the iconURL to something inside the XPI locks the XPI and
|
|
// makes it impossible to delete on Windows.
|
|
//let newIcon = createWrapper(this.addon).iconURL;
|
|
//if (newIcon)
|
|
// this.iconURL = newIcon;
|
|
|
|
addRepositoryData(this.addon);
|
|
},
|
|
|
|
observe: function AI_observe(aSubject, aTopic, aData) {
|
|
// Network is going offline
|
|
this.cancel();
|
|
},
|
|
|
|
/**
|
|
* Starts downloading the add-on's XPI file.
|
|
*/
|
|
startDownload: function AI_startDownload() {
|
|
this.state = AddonManager.STATE_DOWNLOADING;
|
|
if (!AddonManagerPrivate.callInstallListeners("onDownloadStarted",
|
|
this.listeners, this.wrapper)) {
|
|
logger.debug("onDownloadStarted listeners cancelled installation of addon " + this.sourceURI.spec);
|
|
this.state = AddonManager.STATE_CANCELLED;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
|
|
this.listeners, this.wrapper)
|
|
return;
|
|
}
|
|
|
|
// If a listener changed our state then do not proceed with the download
|
|
if (this.state != AddonManager.STATE_DOWNLOADING)
|
|
return;
|
|
|
|
if (this.channel) {
|
|
// A previous download attempt hasn't finished cleaning up yet, signal
|
|
// that it should restart when complete
|
|
logger.debug("Waiting for previous download to complete");
|
|
this.restartDownload = true;
|
|
return;
|
|
}
|
|
|
|
this.openChannel();
|
|
},
|
|
|
|
openChannel: function AI_openChannel() {
|
|
this.restartDownload = false;
|
|
|
|
try {
|
|
this.file = getTemporaryFile();
|
|
this.ownsTempFile = true;
|
|
this.stream = Cc["@mozilla.org/network/file-output-stream;1"].
|
|
createInstance(Ci.nsIFileOutputStream);
|
|
this.stream.init(this.file, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE |
|
|
FileUtils.MODE_TRUNCATE, FileUtils.PERMS_FILE, 0);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to start download for addon " + this.sourceURI.spec, e);
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
this.error = AddonManager.ERROR_FILE_ACCESS;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onDownloadFailed",
|
|
this.listeners, this.wrapper);
|
|
return;
|
|
}
|
|
|
|
let listener = Cc["@mozilla.org/network/stream-listener-tee;1"].
|
|
createInstance(Ci.nsIStreamListenerTee);
|
|
listener.init(this, this.stream);
|
|
try {
|
|
Components.utils.import("resource://gre/modules/CertUtils.jsm");
|
|
let requireBuiltIn = Preferences.get(PREF_INSTALL_REQUIREBUILTINCERTS, true);
|
|
this.badCertHandler = new BadCertHandler(!requireBuiltIn);
|
|
|
|
this.channel = NetUtil.newChannel({
|
|
uri: this.sourceURI,
|
|
loadUsingSystemPrincipal: true
|
|
});
|
|
this.channel.notificationCallbacks = this;
|
|
if (this.channel instanceof Ci.nsIHttpChannel) {
|
|
this.channel.setRequestHeader("Moz-XPI-Update", "1", true);
|
|
if (this.channel instanceof Ci.nsIHttpChannelInternal)
|
|
this.channel.forceAllowThirdPartyCookie = true;
|
|
}
|
|
this.channel.asyncOpen2(listener);
|
|
|
|
Services.obs.addObserver(this, "network:offline-about-to-go-offline", false);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to start download for addon " + this.sourceURI.spec, e);
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
this.error = AddonManager.ERROR_NETWORK_FAILURE;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onDownloadFailed",
|
|
this.listeners, this.wrapper);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Update the crypto hasher with the new data and call the progress listeners.
|
|
*
|
|
* @see nsIStreamListener
|
|
*/
|
|
onDataAvailable: function AI_onDataAvailable(aRequest, aContext, aInputstream,
|
|
aOffset, aCount) {
|
|
this.crypto.updateFromStream(aInputstream, aCount);
|
|
this.progress += aCount;
|
|
if (!AddonManagerPrivate.callInstallListeners("onDownloadProgress",
|
|
this.listeners, this.wrapper)) {
|
|
// TODO cancel the download and make it available again (bug 553024)
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Check the redirect response for a hash of the target XPI and verify that
|
|
* we don't end up on an insecure channel.
|
|
*
|
|
* @see nsIChannelEventSink
|
|
*/
|
|
asyncOnChannelRedirect: function AI_asyncOnChannelRedirect(aOldChannel, aNewChannel, aFlags, aCallback) {
|
|
if (!this.hash && aOldChannel.originalURI.schemeIs("https") &&
|
|
aOldChannel instanceof Ci.nsIHttpChannel) {
|
|
try {
|
|
let hashStr = aOldChannel.getResponseHeader("X-Target-Digest");
|
|
let hashSplit = hashStr.toLowerCase().split(":");
|
|
this.hash = {
|
|
algorithm: hashSplit[0],
|
|
data: hashSplit[1]
|
|
};
|
|
}
|
|
catch (e) {
|
|
}
|
|
}
|
|
|
|
// Verify that we don't end up on an insecure channel if we haven't got a
|
|
// hash to verify with (see bug 537761 for discussion)
|
|
if (!this.hash)
|
|
this.badCertHandler.asyncOnChannelRedirect(aOldChannel, aNewChannel, aFlags, aCallback);
|
|
else
|
|
aCallback.onRedirectVerifyCallback(Cr.NS_OK);
|
|
|
|
this.channel = aNewChannel;
|
|
},
|
|
|
|
/**
|
|
* This is the first chance to get at real headers on the channel.
|
|
*
|
|
* @see nsIStreamListener
|
|
*/
|
|
onStartRequest: function AI_onStartRequest(aRequest, aContext) {
|
|
this.crypto = Cc["@mozilla.org/security/hash;1"].
|
|
createInstance(Ci.nsICryptoHash);
|
|
if (this.hash) {
|
|
try {
|
|
this.crypto.initWithString(this.hash.algorithm);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Unknown hash algorithm '" + this.hash.algorithm + "' for addon " + this.sourceURI.spec, e);
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
this.error = AddonManager.ERROR_INCORRECT_HASH;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onDownloadFailed",
|
|
this.listeners, this.wrapper);
|
|
aRequest.cancel(Cr.NS_BINDING_ABORTED);
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
// We always need something to consume data from the inputstream passed
|
|
// to onDataAvailable so just create a dummy cryptohasher to do that.
|
|
this.crypto.initWithString("sha1");
|
|
}
|
|
|
|
this.progress = 0;
|
|
if (aRequest instanceof Ci.nsIChannel) {
|
|
try {
|
|
this.maxProgress = aRequest.contentLength;
|
|
}
|
|
catch (e) {
|
|
}
|
|
logger.debug("Download started for " + this.sourceURI.spec + " to file " +
|
|
this.file.path);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* The download is complete.
|
|
*
|
|
* @see nsIStreamListener
|
|
*/
|
|
onStopRequest: function AI_onStopRequest(aRequest, aContext, aStatus) {
|
|
this.stream.close();
|
|
this.channel = null;
|
|
this.badCerthandler = null;
|
|
Services.obs.removeObserver(this, "network:offline-about-to-go-offline");
|
|
|
|
// If the download was cancelled then update the state and send events
|
|
if (aStatus == Cr.NS_BINDING_ABORTED) {
|
|
if (this.state == AddonManager.STATE_DOWNLOADING) {
|
|
logger.debug("Cancelled download of " + this.sourceURI.spec);
|
|
this.state = AddonManager.STATE_CANCELLED;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onDownloadCancelled",
|
|
this.listeners, this.wrapper);
|
|
// If a listener restarted the download then there is no need to
|
|
// remove the temporary file
|
|
if (this.state != AddonManager.STATE_CANCELLED)
|
|
return;
|
|
}
|
|
|
|
this.removeTemporaryFile();
|
|
if (this.restartDownload)
|
|
this.openChannel();
|
|
return;
|
|
}
|
|
|
|
logger.debug("Download of " + this.sourceURI.spec + " completed.");
|
|
|
|
if (Components.isSuccessCode(aStatus)) {
|
|
if (!(aRequest instanceof Ci.nsIHttpChannel) || aRequest.requestSucceeded) {
|
|
if (!this.hash && (aRequest instanceof Ci.nsIChannel)) {
|
|
try {
|
|
checkCert(aRequest,
|
|
!Preferences.get(PREF_INSTALL_REQUIREBUILTINCERTS, true));
|
|
}
|
|
catch (e) {
|
|
this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// convert the binary hash data to a hex string.
|
|
let calculatedHash = getHashStringForCrypto(this.crypto);
|
|
this.crypto = null;
|
|
if (this.hash && calculatedHash != this.hash.data) {
|
|
this.downloadFailed(AddonManager.ERROR_INCORRECT_HASH,
|
|
"Downloaded file hash (" + calculatedHash +
|
|
") did not match provided hash (" + this.hash.data + ")");
|
|
return;
|
|
}
|
|
try {
|
|
let self = this;
|
|
this.loadManifest(function onStopRequest_loadManifest() {
|
|
if (self.addon.isCompatible) {
|
|
self.downloadCompleted();
|
|
}
|
|
else {
|
|
// TODO Should we send some event here (bug 557716)?
|
|
self.state = AddonManager.STATE_CHECKING;
|
|
new UpdateChecker(self.addon, {
|
|
onUpdateFinished: function onStopRequest_onUpdateFinished(aAddon) {
|
|
self.downloadCompleted();
|
|
}
|
|
}, AddonManager.UPDATE_WHEN_ADDON_INSTALLED);
|
|
}
|
|
});
|
|
}
|
|
catch (e) {
|
|
if (e.webext) {
|
|
this.downloadFailed(AddonManager.ERROR_WEBEXT_FILE, e);
|
|
#ifndef MOZ_JETPACK
|
|
} else if (e.jetpacksdk) {
|
|
this.downloadFailed(AddonManager.ERROR_JETPACKSDK_FILE, e);
|
|
#endif
|
|
} else {
|
|
this.downloadFailed(AddonManager.ERROR_CORRUPT_FILE, e);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (aRequest instanceof Ci.nsIHttpChannel)
|
|
this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE,
|
|
aRequest.responseStatus + " " +
|
|
aRequest.responseStatusText);
|
|
else
|
|
this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, aStatus);
|
|
}
|
|
}
|
|
else {
|
|
this.downloadFailed(AddonManager.ERROR_NETWORK_FAILURE, aStatus);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Notify listeners that the download failed.
|
|
*
|
|
* @param aReason
|
|
* Something to log about the failure
|
|
* @param error
|
|
* The error code to pass to the listeners
|
|
*/
|
|
downloadFailed: function AI_downloadFailed(aReason, aError) {
|
|
logger.warn("Download of " + this.sourceURI.spec + " failed", aError);
|
|
this.state = AddonManager.STATE_DOWNLOAD_FAILED;
|
|
this.error = aReason;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onDownloadFailed", this.listeners,
|
|
this.wrapper);
|
|
|
|
// If the listener hasn't restarted the download then remove any temporary
|
|
// file
|
|
if (this.state == AddonManager.STATE_DOWNLOAD_FAILED) {
|
|
logger.debug("downloadFailed: removing temp file for " + this.sourceURI.spec);
|
|
this.removeTemporaryFile();
|
|
}
|
|
else
|
|
logger.debug("downloadFailed: listener changed AddonInstall state for " +
|
|
this.sourceURI.spec + " to " + this.state);
|
|
},
|
|
|
|
/**
|
|
* Notify listeners that the download completed.
|
|
*/
|
|
downloadCompleted: function AI_downloadCompleted() {
|
|
let self = this;
|
|
XPIDatabase.getVisibleAddonForID(this.addon.id, function downloadCompleted_getVisibleAddonForID(aAddon) {
|
|
if (aAddon)
|
|
self.existingAddon = aAddon;
|
|
|
|
self.state = AddonManager.STATE_DOWNLOADED;
|
|
self.addon.updateDate = Date.now();
|
|
|
|
if (self.existingAddon) {
|
|
self.addon.existingAddonID = self.existingAddon.id;
|
|
self.addon.installDate = self.existingAddon.installDate;
|
|
applyBlocklistChanges(self.existingAddon, self.addon);
|
|
}
|
|
else {
|
|
self.addon.installDate = self.addon.updateDate;
|
|
}
|
|
|
|
if (AddonManagerPrivate.callInstallListeners("onDownloadEnded",
|
|
self.listeners,
|
|
self.wrapper)) {
|
|
// If a listener changed our state then do not proceed with the install
|
|
if (self.state != AddonManager.STATE_DOWNLOADED)
|
|
return;
|
|
|
|
self.install();
|
|
|
|
if (self.linkedInstalls) {
|
|
self.linkedInstalls.forEach(function(aInstall) {
|
|
aInstall.install();
|
|
});
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
// TODO This relies on the assumption that we are always installing into the
|
|
// highest priority install location so the resulting add-on will be visible
|
|
// overriding any existing copy in another install location (bug 557710).
|
|
/**
|
|
* Installs the add-on into the install location.
|
|
*/
|
|
startInstall: function AI_startInstall() {
|
|
this.state = AddonManager.STATE_INSTALLING;
|
|
if (!AddonManagerPrivate.callInstallListeners("onInstallStarted",
|
|
this.listeners, this.wrapper)) {
|
|
this.state = AddonManager.STATE_DOWNLOADED;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callInstallListeners("onInstallCancelled",
|
|
this.listeners, this.wrapper)
|
|
return;
|
|
}
|
|
|
|
// Find and cancel any pending installs for the same add-on in the same
|
|
// install location
|
|
for (let aInstall of XPIProvider.installs) {
|
|
if (aInstall.state == AddonManager.STATE_INSTALLED &&
|
|
aInstall.installLocation == this.installLocation &&
|
|
aInstall.addon.id == this.addon.id) {
|
|
logger.debug("Cancelling previous pending install of " + aInstall.addon.id);
|
|
aInstall.cancel();
|
|
}
|
|
}
|
|
|
|
let isUpgrade = this.existingAddon &&
|
|
this.existingAddon._installLocation == this.installLocation;
|
|
let requiresRestart = XPIProvider.installRequiresRestart(this.addon);
|
|
|
|
logger.debug("Starting install of " + this.addon.id + " from " + this.sourceURI.spec);
|
|
AddonManagerPrivate.callAddonListeners("onInstalling",
|
|
createWrapper(this.addon),
|
|
requiresRestart);
|
|
|
|
let stagingDir = this.installLocation.getStagingDir();
|
|
let stagedAddon = stagingDir.clone();
|
|
|
|
Task.spawn((function() {
|
|
let installedUnpacked = 0;
|
|
yield this.installLocation.requestStagingDir();
|
|
|
|
// Remove any staged items for this add-on
|
|
stagedAddon.append(this.addon.id);
|
|
yield removeAsync(stagedAddon);
|
|
stagedAddon.leafName = this.addon.id + ".xpi";
|
|
yield removeAsync(stagedAddon);
|
|
|
|
// First stage the file regardless of whether restarting is necessary
|
|
if (this.addon.unpack || Preferences.get(PREF_XPI_UNPACK, false)) {
|
|
logger.debug("Addon " + this.addon.id + " will be installed as " +
|
|
"an unpacked directory");
|
|
stagedAddon.leafName = this.addon.id;
|
|
yield OS.File.makeDir(stagedAddon.path);
|
|
yield ZipUtils.extractFilesAsync(this.file, stagedAddon);
|
|
installedUnpacked = 1;
|
|
}
|
|
else {
|
|
logger.debug("Addon " + this.addon.id + " will be installed as " +
|
|
"a packed xpi");
|
|
stagedAddon.leafName = this.addon.id + ".xpi";
|
|
yield OS.File.copy(this.file.path, stagedAddon.path);
|
|
}
|
|
|
|
if (requiresRestart) {
|
|
// Point the add-on to its extracted files as the xpi may get deleted
|
|
this.addon._sourceBundle = stagedAddon;
|
|
|
|
// Cache the AddonInternal as it may have updated compatibility info
|
|
let stagedJSON = stagedAddon.clone();
|
|
stagedJSON.leafName = this.addon.id + ".json";
|
|
if (stagedJSON.exists())
|
|
stagedJSON.remove(true);
|
|
let stream = Cc["@mozilla.org/network/file-output-stream;1"].
|
|
createInstance(Ci.nsIFileOutputStream);
|
|
let converter = Cc["@mozilla.org/intl/converter-output-stream;1"].
|
|
createInstance(Ci.nsIConverterOutputStream);
|
|
|
|
try {
|
|
stream.init(stagedJSON, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE |
|
|
FileUtils.MODE_TRUNCATE, FileUtils.PERMS_FILE,
|
|
0);
|
|
converter.init(stream, "UTF-8", 0, 0x0000);
|
|
converter.writeString(JSON.stringify(this.addon));
|
|
}
|
|
finally {
|
|
converter.close();
|
|
stream.close();
|
|
}
|
|
|
|
logger.debug("Staged install of " + this.addon.id + " from " + this.sourceURI.spec + " ready; waiting for restart.");
|
|
this.state = AddonManager.STATE_INSTALLED;
|
|
if (isUpgrade) {
|
|
delete this.existingAddon.pendingUpgrade;
|
|
this.existingAddon.pendingUpgrade = this.addon;
|
|
}
|
|
AddonManagerPrivate.callInstallListeners("onInstallEnded",
|
|
this.listeners, this.wrapper,
|
|
createWrapper(this.addon));
|
|
}
|
|
else {
|
|
// The install is completed so it should be removed from the active list
|
|
XPIProvider.removeActiveInstall(this);
|
|
|
|
// TODO We can probably reduce the number of DB operations going on here
|
|
// We probably also want to support rolling back failed upgrades etc.
|
|
// See bug 553015.
|
|
|
|
// Deactivate and remove the old add-on as necessary
|
|
let reason = BOOTSTRAP_REASONS.ADDON_INSTALL;
|
|
if (this.existingAddon) {
|
|
if (Services.vc.compare(this.existingAddon.version, this.addon.version) < 0)
|
|
reason = BOOTSTRAP_REASONS.ADDON_UPGRADE;
|
|
else
|
|
reason = BOOTSTRAP_REASONS.ADDON_DOWNGRADE;
|
|
|
|
if (this.existingAddon.bootstrap) {
|
|
let file = this.existingAddon._installLocation
|
|
.getLocationForID(this.existingAddon.id);
|
|
if (this.existingAddon.active) {
|
|
XPIProvider.callBootstrapMethod(this.existingAddon, file,
|
|
"shutdown", reason,
|
|
{ newVersion: this.addon.version });
|
|
}
|
|
|
|
XPIProvider.callBootstrapMethod(this.existingAddon, file,
|
|
"uninstall", reason,
|
|
{ newVersion: this.addon.version });
|
|
XPIProvider.unloadBootstrapScope(this.existingAddon.id);
|
|
flushChromeCaches();
|
|
}
|
|
|
|
if (!isUpgrade && this.existingAddon.active) {
|
|
XPIDatabase.updateAddonActive(this.existingAddon, false);
|
|
}
|
|
}
|
|
|
|
// Install the new add-on into its final location
|
|
let existingAddonID = this.existingAddon ? this.existingAddon.id : null;
|
|
let file = this.installLocation.installAddon(this.addon.id, stagedAddon,
|
|
existingAddonID);
|
|
|
|
// Update the metadata in the database
|
|
this.addon._sourceBundle = file;
|
|
this.addon._installLocation = this.installLocation;
|
|
this.addon.visible = true;
|
|
|
|
if (isUpgrade) {
|
|
this.addon = XPIDatabase.updateAddonMetadata(this.existingAddon, this.addon,
|
|
file.persistentDescriptor);
|
|
let state = XPIStates.getAddon(this.installLocation.name, this.addon.id);
|
|
if (state) {
|
|
state.syncWithDB(this.addon, true);
|
|
} else {
|
|
logger.warn("Unexpected missing XPI state for add-on ${id}", this.addon);
|
|
}
|
|
}
|
|
else {
|
|
this.addon.active = (this.addon.visible && !this.addon.disabled);
|
|
this.addon = XPIDatabase.addAddonMetadata(this.addon, file.persistentDescriptor);
|
|
XPIStates.addAddon(this.addon);
|
|
this.addon.installDate = this.addon.updateDate;
|
|
XPIDatabase.saveChanges();
|
|
}
|
|
XPIStates.save();
|
|
|
|
let extraParams = {};
|
|
if (this.existingAddon) {
|
|
extraParams.oldVersion = this.existingAddon.version;
|
|
}
|
|
|
|
if (this.addon.bootstrap) {
|
|
XPIProvider.callBootstrapMethod(this.addon, file, "install",
|
|
reason, extraParams);
|
|
}
|
|
|
|
AddonManagerPrivate.callAddonListeners("onInstalled",
|
|
createWrapper(this.addon));
|
|
|
|
logger.debug("Install of " + this.sourceURI.spec + " completed.");
|
|
this.state = AddonManager.STATE_INSTALLED;
|
|
AddonManagerPrivate.callInstallListeners("onInstallEnded",
|
|
this.listeners, this.wrapper,
|
|
createWrapper(this.addon));
|
|
|
|
if (this.addon.bootstrap) {
|
|
if (this.addon.active) {
|
|
XPIProvider.callBootstrapMethod(this.addon, file, "startup",
|
|
reason, extraParams);
|
|
}
|
|
else {
|
|
// XXX this makes it dangerous to do some things in onInstallEnded
|
|
// listeners because important cleanup hasn't been done yet
|
|
XPIProvider.unloadBootstrapScope(this.addon.id);
|
|
}
|
|
}
|
|
}
|
|
}).bind(this)).then(null, (e) => {
|
|
logger.warn("Failed to install " + this.file.path + " from " + this.sourceURI.spec, e);
|
|
if (stagedAddon.exists())
|
|
recursiveRemove(stagedAddon);
|
|
this.state = AddonManager.STATE_INSTALL_FAILED;
|
|
this.error = AddonManager.ERROR_FILE_ACCESS;
|
|
XPIProvider.removeActiveInstall(this);
|
|
AddonManagerPrivate.callAddonListeners("onOperationCancelled",
|
|
createWrapper(this.addon));
|
|
AddonManagerPrivate.callInstallListeners("onInstallFailed",
|
|
this.listeners,
|
|
this.wrapper);
|
|
}).then(() => {
|
|
this.removeTemporaryFile();
|
|
return this.installLocation.releaseStagingDir();
|
|
});
|
|
},
|
|
|
|
getInterface: function AI_getInterface(iid) {
|
|
if (iid.equals(Ci.nsIAuthPrompt2)) {
|
|
let win = this.window;
|
|
if (!win && this.browser)
|
|
win = this.browser.ownerDocument.defaultView;
|
|
|
|
let factory = Cc["@mozilla.org/prompter;1"].
|
|
getService(Ci.nsIPromptFactory);
|
|
let prompt = factory.getPrompt(win, Ci.nsIAuthPrompt2);
|
|
|
|
if (this.browser && this.browser.isRemoteBrowser && prompt instanceof Ci.nsILoginManagerPrompter)
|
|
prompt.setE10sData(this.browser, null);
|
|
|
|
return prompt;
|
|
}
|
|
else if (iid.equals(Ci.nsIChannelEventSink)) {
|
|
return this;
|
|
}
|
|
|
|
return this.badCertHandler.getInterface(iid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new AddonInstall for an already staged install. Used when
|
|
* installing the staged install failed for some reason.
|
|
*
|
|
* @param aDir
|
|
* The directory holding the staged install
|
|
* @param aManifest
|
|
* The cached manifest for the install
|
|
*/
|
|
AddonInstall.createStagedInstall = function AI_createStagedInstall(aInstallLocation, aDir, aManifest) {
|
|
let url = Services.io.newFileURI(aDir);
|
|
|
|
let install = new AddonInstall(aInstallLocation, aDir);
|
|
install.initStagedInstall(aManifest);
|
|
};
|
|
|
|
/**
|
|
* Creates a new AddonInstall to install an add-on from a local file. Installs
|
|
* always go into the profile install location.
|
|
*
|
|
* @param aCallback
|
|
* The callback to pass the new AddonInstall to
|
|
* @param aFile
|
|
* The file to install
|
|
*/
|
|
AddonInstall.createInstall = function AI_createInstall(aCallback, aFile) {
|
|
let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE];
|
|
let url = Services.io.newFileURI(aFile);
|
|
|
|
try {
|
|
let install = new AddonInstall(location, url);
|
|
install.initLocalInstall(aCallback);
|
|
}
|
|
catch(e) {
|
|
logger.error("Error creating install", e);
|
|
makeSafe(aCallback)(null);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Creates a new AddonInstall to download and install a URL.
|
|
*
|
|
* @param aCallback
|
|
* The callback to pass the new AddonInstall to
|
|
* @param aUri
|
|
* The URI to download
|
|
* @param aHash
|
|
* A hash for the add-on
|
|
* @param aName
|
|
* A name for the add-on
|
|
* @param aIcons
|
|
* An icon URLs for the add-on
|
|
* @param aVersion
|
|
* A version for the add-on
|
|
* @param aBrowser
|
|
* The browser performing the install
|
|
*/
|
|
AddonInstall.createDownload = function AI_createDownload(aCallback, aUri, aHash, aName, aIcons,
|
|
aVersion, aBrowser) {
|
|
let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE];
|
|
let url = NetUtil.newURI(aUri);
|
|
|
|
let install = new AddonInstall(location, url, aHash, null, null, aBrowser);
|
|
if (url instanceof Ci.nsIFileURL)
|
|
install.initLocalInstall(aCallback);
|
|
else
|
|
install.initAvailableDownload(aName, null, aIcons, aVersion, aCallback);
|
|
};
|
|
|
|
/**
|
|
* Creates a new AddonInstall for an update.
|
|
*
|
|
* @param aCallback
|
|
* The callback to pass the new AddonInstall to
|
|
* @param aAddon
|
|
* The add-on being updated
|
|
* @param aUpdate
|
|
* The metadata about the new version from the update manifest
|
|
*/
|
|
AddonInstall.createUpdate = function AI_createUpdate(aCallback, aAddon, aUpdate) {
|
|
let url = NetUtil.newURI(aUpdate.updateURL);
|
|
let releaseNotesURI = null;
|
|
try {
|
|
if (aUpdate.updateInfoURL)
|
|
releaseNotesURI = NetUtil.newURI(escapeAddonURI(aAddon, aUpdate.updateInfoURL));
|
|
}
|
|
catch (e) {
|
|
// If the releaseNotesURI cannot be parsed then just ignore it.
|
|
}
|
|
|
|
let install = new AddonInstall(aAddon._installLocation, url,
|
|
aUpdate.updateHash, releaseNotesURI, aAddon);
|
|
if (url instanceof Ci.nsIFileURL) {
|
|
install.initLocalInstall(aCallback);
|
|
}
|
|
else {
|
|
install.initAvailableDownload(aAddon.selectedLocale.name ?
|
|
aAddon.selectedLocale.name : aAddon.defaultLocale.name,
|
|
aAddon.type, aAddon.icons, aUpdate.version, aCallback);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Creates a wrapper for an AddonInstall that only exposes the public API
|
|
*
|
|
* @param install
|
|
* The AddonInstall to create a wrapper for
|
|
*/
|
|
function AddonInstallWrapper(aInstall) {
|
|
#ifdef MOZ_EM_DEBUG
|
|
this.__defineGetter__("__AddonInstallInternal__", function AIW_debugGetter() {
|
|
return aInstall;
|
|
});
|
|
#endif
|
|
|
|
["name", "type", "version", "icons", "releaseNotesURI", "file", "state", "error",
|
|
"progress", "maxProgress", "certificate", "certName"].forEach(function(aProp) {
|
|
this.__defineGetter__(aProp, function AIW_propertyGetter() aInstall[aProp]);
|
|
}, this);
|
|
|
|
this.__defineGetter__("iconURL", function AIW_iconURL() aInstall.icons[32]);
|
|
|
|
this.__defineGetter__("existingAddon", function AIW_existingAddonGetter() {
|
|
return createWrapper(aInstall.existingAddon);
|
|
});
|
|
this.__defineGetter__("addon", function AIW_addonGetter() createWrapper(aInstall.addon));
|
|
this.__defineGetter__("sourceURI", function AIW_sourceURIGetter() aInstall.sourceURI);
|
|
|
|
this.__defineGetter__("linkedInstalls", function AIW_linkedInstallsGetter() {
|
|
if (!aInstall.linkedInstalls)
|
|
return null;
|
|
// Tycho: return [i.wrapper for each (i in aInstall.linkedInstalls)];
|
|
let result = [];
|
|
for each (let i in aInstall.linkedInstalls) {
|
|
result.push(i.wrapper);
|
|
}
|
|
|
|
return result;
|
|
});
|
|
|
|
this.install = function AIW_install() {
|
|
aInstall.install();
|
|
}
|
|
|
|
this.cancel = function AIW_cancel() {
|
|
aInstall.cancel();
|
|
}
|
|
|
|
this.addListener = function AIW_addListener(listener) {
|
|
aInstall.addListener(listener);
|
|
}
|
|
|
|
this.removeListener = function AIW_removeListener(listener) {
|
|
aInstall.removeListener(listener);
|
|
}
|
|
}
|
|
|
|
AddonInstallWrapper.prototype = {};
|
|
|
|
/**
|
|
* Creates a new update checker.
|
|
*
|
|
* @param aAddon
|
|
* The add-on to check for updates
|
|
* @param aListener
|
|
* An UpdateListener to notify of updates
|
|
* @param aReason
|
|
* The reason for the update check
|
|
* @param aAppVersion
|
|
* An optional application version to check for updates for
|
|
* @param aPlatformVersion
|
|
* An optional platform version to check for updates for
|
|
* @throws if the aListener or aReason arguments are not valid
|
|
*/
|
|
function UpdateChecker(aAddon, aListener, aReason, aAppVersion, aPlatformVersion) {
|
|
if (!aListener || !aReason)
|
|
throw Cr.NS_ERROR_INVALID_ARG;
|
|
|
|
Components.utils.import("resource://gre/modules/addons/AddonUpdateChecker.jsm");
|
|
|
|
this.addon = aAddon;
|
|
aAddon._updateCheck = this;
|
|
XPIProvider.doing(this);
|
|
this.listener = aListener;
|
|
this.appVersion = aAppVersion;
|
|
this.platformVersion = aPlatformVersion;
|
|
this.syncCompatibility = (aReason == AddonManager.UPDATE_WHEN_NEW_APP_INSTALLED);
|
|
|
|
let updateURL = aAddon.updateURL;
|
|
if (!updateURL) {
|
|
updateURL = Services.prefs.getCharPref(PREF_EM_UPDATE_URL);
|
|
}
|
|
|
|
const UPDATE_TYPE_COMPATIBILITY = 32;
|
|
const UPDATE_TYPE_NEWVERSION = 64;
|
|
|
|
aReason |= UPDATE_TYPE_COMPATIBILITY;
|
|
if ("onUpdateAvailable" in this.listener)
|
|
aReason |= UPDATE_TYPE_NEWVERSION;
|
|
|
|
let url = escapeAddonURI(aAddon, updateURL, aReason, aAppVersion);
|
|
this._parser = AddonUpdateChecker.checkForUpdates(aAddon.id, aAddon.updateKey,
|
|
url, this);
|
|
}
|
|
|
|
UpdateChecker.prototype = {
|
|
addon: null,
|
|
listener: null,
|
|
appVersion: null,
|
|
platformVersion: null,
|
|
syncCompatibility: null,
|
|
|
|
/**
|
|
* Calls a method on the listener passing any number of arguments and
|
|
* consuming any exceptions.
|
|
*
|
|
* @param aMethod
|
|
* The method to call on the listener
|
|
*/
|
|
callListener: function UC_callListener(aMethod, ...aArgs) {
|
|
if (!(aMethod in this.listener))
|
|
return;
|
|
|
|
try {
|
|
this.listener[aMethod].apply(this.listener, aArgs);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Exception calling UpdateListener method " + aMethod, e);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when AddonUpdateChecker completes the update check
|
|
*
|
|
* @param updates
|
|
* The list of update details for the add-on
|
|
*/
|
|
onUpdateCheckComplete: function UC_onUpdateCheckComplete(aUpdates) {
|
|
XPIProvider.done(this.addon._updateCheck);
|
|
this.addon._updateCheck = null;
|
|
let AUC = AddonUpdateChecker;
|
|
|
|
let ignoreMaxVersion = false;
|
|
let ignoreStrictCompat = false;
|
|
if (!AddonManager.checkCompatibility) {
|
|
ignoreMaxVersion = true;
|
|
ignoreStrictCompat = true;
|
|
} else if (this.addon.type in COMPATIBLE_BY_DEFAULT_TYPES &&
|
|
!AddonManager.strictCompatibility &&
|
|
!this.addon.strictCompatibility &&
|
|
!this.addon.hasBinaryComponents) {
|
|
ignoreMaxVersion = true;
|
|
}
|
|
|
|
// Always apply any compatibility update for the current version
|
|
let compatUpdate = AUC.getCompatibilityUpdate(aUpdates, this.addon.version,
|
|
this.syncCompatibility,
|
|
null, null,
|
|
ignoreMaxVersion,
|
|
ignoreStrictCompat);
|
|
// Apply the compatibility update to the database
|
|
if (compatUpdate)
|
|
this.addon.applyCompatibilityUpdate(compatUpdate, this.syncCompatibility);
|
|
|
|
// If the request is for an application or platform version that is
|
|
// different to the current application or platform version then look for a
|
|
// compatibility update for those versions.
|
|
if ((this.appVersion &&
|
|
Services.vc.compare(this.appVersion, Services.appinfo.version) != 0) ||
|
|
(this.platformVersion &&
|
|
Services.vc.compare(this.platformVersion, Services.appinfo.platformVersion) != 0)) {
|
|
compatUpdate = AUC.getCompatibilityUpdate(aUpdates, this.addon.version,
|
|
false, this.appVersion,
|
|
this.platformVersion,
|
|
ignoreMaxVersion,
|
|
ignoreStrictCompat);
|
|
}
|
|
|
|
if (compatUpdate)
|
|
this.callListener("onCompatibilityUpdateAvailable", createWrapper(this.addon));
|
|
else
|
|
this.callListener("onNoCompatibilityUpdateAvailable", createWrapper(this.addon));
|
|
|
|
function sendUpdateAvailableMessages(aSelf, aInstall) {
|
|
if (aInstall) {
|
|
aSelf.callListener("onUpdateAvailable", createWrapper(aSelf.addon),
|
|
aInstall.wrapper);
|
|
}
|
|
else {
|
|
aSelf.callListener("onNoUpdateAvailable", createWrapper(aSelf.addon));
|
|
}
|
|
aSelf.callListener("onUpdateFinished", createWrapper(aSelf.addon),
|
|
AddonManager.UPDATE_STATUS_NO_ERROR);
|
|
}
|
|
|
|
let compatOverrides = AddonManager.strictCompatibility ?
|
|
null :
|
|
this.addon.compatibilityOverrides;
|
|
|
|
let update = AUC.getNewestCompatibleUpdate(aUpdates,
|
|
this.appVersion,
|
|
this.platformVersion,
|
|
ignoreMaxVersion,
|
|
ignoreStrictCompat,
|
|
compatOverrides);
|
|
|
|
if (update && Services.vc.compare(this.addon.version, update.version) < 0) {
|
|
for (let currentInstall of XPIProvider.installs) {
|
|
// Skip installs that don't match the available update
|
|
if (currentInstall.existingAddon != this.addon ||
|
|
currentInstall.version != update.version)
|
|
continue;
|
|
|
|
// If the existing install has not yet started downloading then send an
|
|
// available update notification. If it is already downloading then
|
|
// don't send any available update notification
|
|
if (currentInstall.state == AddonManager.STATE_AVAILABLE) {
|
|
logger.debug("Found an existing AddonInstall for " + this.addon.id);
|
|
sendUpdateAvailableMessages(this, currentInstall);
|
|
}
|
|
else
|
|
sendUpdateAvailableMessages(this, null);
|
|
return;
|
|
}
|
|
|
|
let self = this;
|
|
AddonInstall.createUpdate(function onUpdateCheckComplete_createUpdate(aInstall) {
|
|
sendUpdateAvailableMessages(self, aInstall);
|
|
}, this.addon, update);
|
|
}
|
|
else {
|
|
sendUpdateAvailableMessages(this, null);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Called when AddonUpdateChecker fails the update check
|
|
*
|
|
* @param aError
|
|
* An error status
|
|
*/
|
|
onUpdateCheckError: function UC_onUpdateCheckError(aError) {
|
|
XPIProvider.done(this.addon._updateCheck);
|
|
this.addon._updateCheck = null;
|
|
this.callListener("onNoCompatibilityUpdateAvailable", createWrapper(this.addon));
|
|
this.callListener("onNoUpdateAvailable", createWrapper(this.addon));
|
|
this.callListener("onUpdateFinished", createWrapper(this.addon), aError);
|
|
},
|
|
|
|
/**
|
|
* Called to cancel an in-progress update check
|
|
*/
|
|
cancel: function UC_cancel() {
|
|
let parser = this._parser;
|
|
if (parser) {
|
|
this._parser = null;
|
|
// This will call back to onUpdateCheckError with a CANCELLED error
|
|
parser.cancel();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* The AddonInternal is an internal only representation of add-ons. It may
|
|
* have come from the database (see DBAddonInternal in XPIProviderUtils.jsm)
|
|
* or an install manifest.
|
|
*/
|
|
function AddonInternal() {
|
|
}
|
|
|
|
AddonInternal.prototype = {
|
|
_selectedLocale: null,
|
|
active: false,
|
|
visible: false,
|
|
userDisabled: false,
|
|
appDisabled: false,
|
|
softDisabled: false,
|
|
sourceURI: null,
|
|
releaseNotesURI: null,
|
|
foreignInstall: false,
|
|
|
|
get selectedLocale() {
|
|
if (this._selectedLocale)
|
|
return this._selectedLocale;
|
|
let locale = findClosestLocale(this.locales);
|
|
this._selectedLocale = locale ? locale : this.defaultLocale;
|
|
return this._selectedLocale;
|
|
},
|
|
|
|
get providesUpdatesSecurely() {
|
|
return !!(this.updateKey || !this.updateURL ||
|
|
this.updateURL.substring(0, 6) == "https:");
|
|
},
|
|
|
|
get isCompatible() {
|
|
return this.isCompatibleWith();
|
|
},
|
|
|
|
get disabled() {
|
|
return (this.userDisabled || this.appDisabled || this.softDisabled);
|
|
},
|
|
|
|
get isPlatformCompatible() {
|
|
if (this.targetPlatforms.length == 0)
|
|
return true;
|
|
|
|
let matchedOS = false;
|
|
|
|
// If any targetPlatform matches the OS and contains an ABI then we will
|
|
// only match a targetPlatform that contains both the current OS and ABI
|
|
let needsABI = false;
|
|
|
|
// Some platforms do not specify an ABI, test against null in that case.
|
|
let abi = null;
|
|
try {
|
|
abi = Services.appinfo.XPCOMABI;
|
|
}
|
|
catch (e) { }
|
|
|
|
// Something is causing errors in here
|
|
try {
|
|
for (let platform of this.targetPlatforms) {
|
|
if (platform.os == Services.appinfo.OS) {
|
|
if (platform.abi) {
|
|
needsABI = true;
|
|
if (platform.abi === abi)
|
|
return true;
|
|
}
|
|
else {
|
|
matchedOS = true;
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
let message = "Problem with addon " + this.id + " targetPlatforms "
|
|
+ JSON.stringify(this.targetPlatforms);
|
|
logger.error(message, e);
|
|
AddonManagerPrivate.recordException("XPI", message, e);
|
|
// don't trust this add-on
|
|
return false;
|
|
}
|
|
|
|
return matchedOS && !needsABI;
|
|
},
|
|
|
|
isCompatibleWith: function AddonInternal_isCompatibleWith(aAppVersion, aPlatformVersion) {
|
|
// Experiments are installed through an external mechanism that
|
|
// limits target audience to compatible clients. We trust it knows what
|
|
// it's doing and skip compatibility checks.
|
|
//
|
|
// This decision does forfeit defense in depth. If the experiments system
|
|
// is ever wrong about targeting an add-on to a specific application
|
|
// or platform, the client will likely see errors.
|
|
if (this.type == "experiment") {
|
|
return true;
|
|
}
|
|
|
|
let app = this.matchingTargetApplication;
|
|
if (!app)
|
|
return false;
|
|
|
|
if (!aAppVersion)
|
|
aAppVersion = Services.appinfo.version;
|
|
if (!aPlatformVersion)
|
|
aPlatformVersion = Services.appinfo.platformVersion;
|
|
|
|
#ifdef MOZ_PHOENIX_EXTENSIONS
|
|
this.native = false;
|
|
#endif
|
|
|
|
let version;
|
|
if (app.id == Services.appinfo.ID) {
|
|
version = aAppVersion;
|
|
#ifdef MOZ_PHOENIX_EXTENSIONS
|
|
this.native = true;
|
|
}
|
|
else if (app.id == FIREFOX_ID) {
|
|
version = FIREFOX_APPCOMPATVERSION;
|
|
if (this.type == "locale")
|
|
//Never allow language packs in Firefox compatibility mode
|
|
return false;
|
|
#endif
|
|
}
|
|
else if (app.id == TOOLKIT_ID) {
|
|
#ifdef MOZ_PHOENIX_EXTENSIONS
|
|
this.native = true;
|
|
#endif
|
|
version = aPlatformVersion;
|
|
}
|
|
|
|
// Only extensions and dictionaries can be compatible by default; themes
|
|
// and language packs always use strict compatibility checking.
|
|
if (this.type in COMPATIBLE_BY_DEFAULT_TYPES &&
|
|
!AddonManager.strictCompatibility && !this.strictCompatibility &&
|
|
!this.hasBinaryComponents) {
|
|
|
|
// The repository can specify compatibility overrides.
|
|
// Note: For now, only blacklisting is supported by overrides.
|
|
if (this._repositoryAddon &&
|
|
this._repositoryAddon.compatibilityOverrides) {
|
|
let overrides = this._repositoryAddon.compatibilityOverrides;
|
|
let override = AddonRepository.findMatchingCompatOverride(this.version,
|
|
overrides);
|
|
if (override && override.type == "incompatible")
|
|
return false;
|
|
}
|
|
|
|
// Extremely old extensions should not be compatible by default.
|
|
let minCompatVersion;
|
|
#ifdef MOZ_PHOENIX_EXTENSIONS
|
|
if (app.id == Services.appinfo.ID || app.id == FIREFOX_ID)
|
|
#else
|
|
if (app.id == Services.appinfo.ID)
|
|
#endif
|
|
minCompatVersion = XPIProvider.minCompatibleAppVersion;
|
|
else if (app.id == TOOLKIT_ID)
|
|
minCompatVersion = XPIProvider.minCompatiblePlatformVersion;
|
|
|
|
if (minCompatVersion &&
|
|
Services.vc.compare(minCompatVersion, app.maxVersion) > 0)
|
|
return false;
|
|
|
|
return Services.vc.compare(version, app.minVersion) >= 0;
|
|
}
|
|
|
|
return (Services.vc.compare(version, app.minVersion) >= 0) &&
|
|
(Services.vc.compare(version, app.maxVersion) <= 0)
|
|
},
|
|
|
|
get matchingTargetApplication() {
|
|
let app = null;
|
|
for (let targetApp of this.targetApplications) {
|
|
if (targetApp.id == Services.appinfo.ID)
|
|
return targetApp;
|
|
if (targetApp.id == TOOLKIT_ID)
|
|
app = targetApp;
|
|
}
|
|
#ifdef MOZ_PHOENIX_EXTENSIONS
|
|
//Special case: check for Firefox TargetApps. this has to be done AFTER
|
|
//the initial check to make sure appinfo.ID is preferred, even if
|
|
//Firefox is listed before it in the install manifest.
|
|
for (let targetApp of this.targetApplications) {
|
|
if (targetApp.id == FIREFOX_ID) //Firefox GUID
|
|
return targetApp;
|
|
}
|
|
#endif
|
|
// Return toolkit ID if toolkit.
|
|
return app;
|
|
},
|
|
|
|
get blocklistState() {
|
|
let staticItem = findMatchingStaticBlocklistItem(this);
|
|
if (staticItem)
|
|
return staticItem.level;
|
|
|
|
return Blocklist.getAddonBlocklistState(createWrapper(this));
|
|
},
|
|
|
|
get blocklistURL() {
|
|
let staticItem = findMatchingStaticBlocklistItem(this);
|
|
if (staticItem) {
|
|
let url = Services.urlFormatter.formatURLPref("extensions.blocklist.itemURL");
|
|
return url.replace(/%blockID%/g, staticItem.blockID);
|
|
}
|
|
|
|
return Blocklist.getAddonBlocklistURL(createWrapper(this));
|
|
},
|
|
|
|
applyCompatibilityUpdate: function AddonInternal_applyCompatibilityUpdate(aUpdate, aSyncCompatibility) {
|
|
if (this.strictCompatibility) {
|
|
return;
|
|
}
|
|
this.targetApplications.forEach(function(aTargetApp) {
|
|
aUpdate.targetApplications.forEach(function(aUpdateTarget) {
|
|
if (aTargetApp.id == aUpdateTarget.id && (aSyncCompatibility ||
|
|
Services.vc.compare(aTargetApp.maxVersion, aUpdateTarget.maxVersion) < 0)) {
|
|
aTargetApp.minVersion = aUpdateTarget.minVersion;
|
|
aTargetApp.maxVersion = aUpdateTarget.maxVersion;
|
|
}
|
|
});
|
|
});
|
|
if (aUpdate.multiprocessCompatible !== undefined)
|
|
this.multiprocessCompatible = aUpdate.multiprocessCompatible;
|
|
this.appDisabled = !isUsableAddon(this);
|
|
},
|
|
|
|
/**
|
|
* getDataDirectory tries to execute the callback with two arguments:
|
|
* 1) the path of the data directory within the profile,
|
|
* 2) any exception generated from trying to build it.
|
|
*/
|
|
getDataDirectory: function(callback) {
|
|
let parentPath = OS.Path.join(OS.Constants.Path.profileDir, "extension-data");
|
|
let dirPath = OS.Path.join(parentPath, this.id);
|
|
|
|
Task.spawn(function*() {
|
|
yield OS.File.makeDir(parentPath, {ignoreExisting: true});
|
|
yield OS.File.makeDir(dirPath, {ignoreExisting: true});
|
|
}).then(() => callback(dirPath, null),
|
|
e => callback(dirPath, e));
|
|
},
|
|
|
|
/**
|
|
* toJSON is called by JSON.stringify in order to create a filtered version
|
|
* of this object to be serialized to a JSON file. A new object is returned
|
|
* with copies of all non-private properties. Functions, getters and setters
|
|
* are not copied.
|
|
*
|
|
* @param aKey
|
|
* The key that this object is being serialized as in the JSON.
|
|
* Unused here since this is always the main object serialized
|
|
*
|
|
* @return an object containing copies of the properties of this object
|
|
* ignoring private properties, functions, getters and setters
|
|
*/
|
|
toJSON: function AddonInternal_toJSON(aKey) {
|
|
let obj = {};
|
|
for (let prop in this) {
|
|
// Ignore private properties
|
|
if (prop.substring(0, 1) == "_")
|
|
continue;
|
|
|
|
// Ignore getters
|
|
if (this.__lookupGetter__(prop))
|
|
continue;
|
|
|
|
// Ignore setters
|
|
if (this.__lookupSetter__(prop))
|
|
continue;
|
|
|
|
// Ignore functions
|
|
if (typeof this[prop] == "function")
|
|
continue;
|
|
|
|
obj[prop] = this[prop];
|
|
}
|
|
|
|
return obj;
|
|
},
|
|
|
|
/**
|
|
* When an add-on install is pending its metadata will be cached in a file.
|
|
* This method reads particular properties of that metadata that may be newer
|
|
* than that in the install manifest, like compatibility information.
|
|
*
|
|
* @param aObj
|
|
* A JS object containing the cached metadata
|
|
*/
|
|
importMetadata: function AddonInternal_importMetaData(aObj) {
|
|
PENDING_INSTALL_METADATA.forEach(function(aProp) {
|
|
if (!(aProp in aObj))
|
|
return;
|
|
|
|
this[aProp] = aObj[aProp];
|
|
}, this);
|
|
|
|
// Compatibility info may have changed so update appDisabled
|
|
this.appDisabled = !isUsableAddon(this);
|
|
},
|
|
|
|
permissions: function AddonInternal_permissions() {
|
|
let permissions = 0;
|
|
|
|
// Add-ons that aren't installed cannot be modified in any way
|
|
if (!(this.inDatabase))
|
|
return permissions;
|
|
|
|
// Experiments can only be uninstalled. An uninstall reflects the user
|
|
// intent of "disable this experiment." This is partially managed by the
|
|
// experiments manager.
|
|
if (this.type == "experiment") {
|
|
return AddonManager.PERM_CAN_UNINSTALL;
|
|
}
|
|
|
|
if (!this.appDisabled) {
|
|
if (this.userDisabled || this.softDisabled) {
|
|
permissions |= AddonManager.PERM_CAN_ENABLE;
|
|
}
|
|
else if (this.type != "theme") {
|
|
permissions |= AddonManager.PERM_CAN_DISABLE;
|
|
}
|
|
}
|
|
|
|
// Add-ons that are in locked install locations, or are pending uninstall
|
|
// cannot be upgraded or uninstalled
|
|
if (!this._installLocation.locked && !this.pendingUninstall) {
|
|
// Add-ons that are installed by a file link cannot be upgraded
|
|
if (!this._installLocation.isLinkedAddon(this.id)) {
|
|
permissions |= AddonManager.PERM_CAN_UPGRADE;
|
|
}
|
|
|
|
permissions |= AddonManager.PERM_CAN_UNINSTALL;
|
|
}
|
|
|
|
return permissions;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Creates an AddonWrapper for an AddonInternal.
|
|
*
|
|
* @param addon
|
|
* The AddonInternal to wrap
|
|
* @return an AddonWrapper or null if addon was null
|
|
*/
|
|
function createWrapper(aAddon) {
|
|
if (!aAddon)
|
|
return null;
|
|
if (!aAddon._wrapper) {
|
|
aAddon._hasResourceCache = new Map();
|
|
aAddon._wrapper = new AddonWrapper(aAddon);
|
|
}
|
|
return aAddon._wrapper;
|
|
}
|
|
|
|
/**
|
|
* The AddonWrapper wraps an Addon to provide the data visible to consumers of
|
|
* the public API.
|
|
*/
|
|
function AddonWrapper(aAddon) {
|
|
#ifdef MOZ_EM_DEBUG
|
|
this.__defineGetter__("__AddonInternal__", function AW_debugGetter() {
|
|
return aAddon;
|
|
});
|
|
#endif
|
|
|
|
function chooseValue(aObj, aProp) {
|
|
let repositoryAddon = aAddon._repositoryAddon;
|
|
let objValue = aObj[aProp];
|
|
|
|
if (repositoryAddon && (aProp in repositoryAddon) &&
|
|
(objValue === undefined || objValue === null)) {
|
|
return [repositoryAddon[aProp], true];
|
|
}
|
|
|
|
return [objValue, false];
|
|
}
|
|
|
|
["id", "syncGUID", "version", "type", "isCompatible", "isPlatformCompatible",
|
|
"providesUpdatesSecurely", "blocklistState", "blocklistURL", "appDisabled",
|
|
"softDisabled", "skinnable", "size", "foreignInstall", "hasBinaryComponents",
|
|
"strictCompatibility", "compatibilityOverrides", "updateURL",
|
|
"getDataDirectory", "multiprocessCompatible", "native"].forEach(function(aProp) {
|
|
this.__defineGetter__(aProp, function AddonWrapper_propertyGetter() aAddon[aProp]);
|
|
}, this);
|
|
|
|
["fullDescription", "developerComments", "eula", "supportURL",
|
|
"contributionURL", "contributionAmount", "averageRating", "reviewCount",
|
|
"reviewURL", "totalDownloads", "weeklyDownloads", "dailyUsers",
|
|
"repositoryStatus"].forEach(function(aProp) {
|
|
this.__defineGetter__(aProp, function AddonWrapper_repoPropertyGetter() {
|
|
if (aAddon._repositoryAddon)
|
|
return aAddon._repositoryAddon[aProp];
|
|
|
|
return null;
|
|
});
|
|
}, this);
|
|
|
|
this.__defineGetter__("aboutURL", function AddonWrapper_aboutURLGetter() {
|
|
return this.isActive ? aAddon["aboutURL"] : null;
|
|
});
|
|
|
|
["installDate", "updateDate"].forEach(function(aProp) {
|
|
this.__defineGetter__(aProp, function AddonWrapper_datePropertyGetter() new Date(aAddon[aProp]));
|
|
}, this);
|
|
|
|
["sourceURI", "releaseNotesURI"].forEach(function(aProp) {
|
|
this.__defineGetter__(aProp, function AddonWrapper_URIPropertyGetter() {
|
|
let [target, fromRepo] = chooseValue(aAddon, aProp);
|
|
if (!target)
|
|
return null;
|
|
if (fromRepo)
|
|
return target;
|
|
return NetUtil.newURI(target);
|
|
});
|
|
}, this);
|
|
|
|
this.__defineGetter__("optionsURL", function AddonWrapper_optionsURLGetter() {
|
|
if (this.isActive && aAddon.optionsURL)
|
|
return aAddon.optionsURL;
|
|
|
|
if (this.isActive && this.hasResource("options.xul"))
|
|
return this.getResourceURI("options.xul").spec;
|
|
|
|
return null;
|
|
}, this);
|
|
|
|
this.__defineGetter__("optionsType", function AddonWrapper_optionsTypeGetter() {
|
|
if (!this.isActive)
|
|
return null;
|
|
|
|
let hasOptionsXUL = this.hasResource("options.xul");
|
|
let hasOptionsURL = !!this.optionsURL;
|
|
|
|
if (aAddon.optionsType) {
|
|
switch (parseInt(aAddon.optionsType, 10)) {
|
|
case AddonManager.OPTIONS_TYPE_DIALOG:
|
|
case AddonManager.OPTIONS_TYPE_TAB:
|
|
return hasOptionsURL ? aAddon.optionsType : null;
|
|
case AddonManager.OPTIONS_TYPE_INLINE:
|
|
case AddonManager.OPTIONS_TYPE_INLINE_INFO:
|
|
return (hasOptionsXUL || hasOptionsURL) ? aAddon.optionsType : null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
if (hasOptionsXUL)
|
|
return AddonManager.OPTIONS_TYPE_INLINE;
|
|
|
|
if (hasOptionsURL)
|
|
return AddonManager.OPTIONS_TYPE_DIALOG;
|
|
|
|
return null;
|
|
}, this);
|
|
|
|
this.__defineGetter__("iconURL", function AddonWrapper_iconURLGetter() {
|
|
return this.icons[32] || undefined;
|
|
}, this);
|
|
|
|
this.__defineGetter__("icon64URL", function AddonWrapper_icon64URLGetter() {
|
|
return this.icons[64] || undefined;
|
|
}, this);
|
|
|
|
this.__defineGetter__("icons", function AddonWrapper_iconsGetter() {
|
|
let icons = {};
|
|
if (aAddon._repositoryAddon) {
|
|
for (let size in aAddon._repositoryAddon.icons) {
|
|
icons[size] = aAddon._repositoryAddon.icons[size];
|
|
}
|
|
}
|
|
if (this.isActive && aAddon.iconURL) {
|
|
icons[32] = aAddon.iconURL;
|
|
} else if (this.hasResource("icon.png")) {
|
|
icons[32] = this.getResourceURI("icon.png").spec;
|
|
}
|
|
if (this.isActive && aAddon.icon64URL) {
|
|
icons[64] = aAddon.icon64URL;
|
|
} else if (this.hasResource("icon64.png")) {
|
|
icons[64] = this.getResourceURI("icon64.png").spec;
|
|
}
|
|
Object.freeze(icons);
|
|
return icons;
|
|
}, this);
|
|
|
|
PROP_LOCALE_SINGLE.forEach(function(aProp) {
|
|
this.__defineGetter__(aProp, function AddonWrapper_singleLocaleGetter() {
|
|
// Override XPI creator if repository creator is defined
|
|
if (aProp == "creator" &&
|
|
aAddon._repositoryAddon && aAddon._repositoryAddon.creator) {
|
|
return aAddon._repositoryAddon.creator;
|
|
}
|
|
|
|
let result = null;
|
|
|
|
if (aAddon.active) {
|
|
try {
|
|
let pref = PREF_EM_EXTENSION_FORMAT + aAddon.id + "." + aProp;
|
|
let value = Preferences.get(pref, null, Ci.nsIPrefLocalizedString);
|
|
if (value)
|
|
result = value;
|
|
}
|
|
catch (e) {
|
|
}
|
|
}
|
|
|
|
if (result == null) {
|
|
if (typeof aAddon.selectedLocale[aProp] == "string" && aAddon.selectedLocale[aProp].length)
|
|
[result, ] = chooseValue(aAddon.selectedLocale, aProp);
|
|
else
|
|
[result, ] = chooseValue(aAddon.defaultLocale, aProp);
|
|
}
|
|
|
|
if (aProp == "creator")
|
|
return result ? new AddonManagerPrivate.AddonAuthor(result) : null;
|
|
|
|
return result;
|
|
});
|
|
}, this);
|
|
|
|
PROP_LOCALE_MULTI.forEach(function(aProp) {
|
|
this.__defineGetter__(aProp, function AddonWrapper_multiLocaleGetter() {
|
|
let results = null;
|
|
let usedRepository = false;
|
|
|
|
if (aAddon.active) {
|
|
let pref = PREF_EM_EXTENSION_FORMAT + aAddon.id + "." +
|
|
aProp.substring(0, aProp.length - 1);
|
|
let list = Services.prefs.getChildList(pref, {});
|
|
if (list.length > 0) {
|
|
list.sort();
|
|
results = [];
|
|
list.forEach(function(aPref) {
|
|
let value = Preferences.get(aPref, null, Ci.nsIPrefLocalizedString);
|
|
if (value)
|
|
results.push(value);
|
|
});
|
|
}
|
|
}
|
|
|
|
if (results == null) {
|
|
if (aAddon.selectedLocale[aProp] instanceof Array && aAddon.selectedLocale[aProp].length)
|
|
[results, usedRepository] = chooseValue(aAddon.selectedLocale, aProp);
|
|
else
|
|
[results, usedRepository] = chooseValue(aAddon.defaultLocale, aProp);
|
|
}
|
|
|
|
if (results && !usedRepository) {
|
|
results = results.map(function mapResult(aResult) {
|
|
return new AddonManagerPrivate.AddonAuthor(aResult);
|
|
});
|
|
}
|
|
|
|
return results;
|
|
});
|
|
}, this);
|
|
|
|
this.__defineGetter__("screenshots", function AddonWrapper_screenshotsGetter() {
|
|
let repositoryAddon = aAddon._repositoryAddon;
|
|
if (repositoryAddon && ("screenshots" in repositoryAddon)) {
|
|
let repositoryScreenshots = repositoryAddon.screenshots;
|
|
if (repositoryScreenshots && repositoryScreenshots.length > 0)
|
|
return repositoryScreenshots;
|
|
}
|
|
|
|
if (aAddon.type == "theme" && this.hasResource("preview.png")) {
|
|
let url = this.getResourceURI("preview.png").spec;
|
|
return [new AddonManagerPrivate.AddonScreenshot(url)];
|
|
}
|
|
|
|
return null;
|
|
});
|
|
|
|
this.__defineGetter__("applyBackgroundUpdates", function AddonWrapper_applyBackgroundUpdatesGetter() {
|
|
return aAddon.applyBackgroundUpdates;
|
|
});
|
|
this.__defineSetter__("applyBackgroundUpdates", function AddonWrapper_applyBackgroundUpdatesSetter(val) {
|
|
if (this.type == "experiment") {
|
|
logger.warn("Setting applyBackgroundUpdates on an experiment is not supported.");
|
|
return;
|
|
}
|
|
|
|
if (val != AddonManager.AUTOUPDATE_DEFAULT &&
|
|
val != AddonManager.AUTOUPDATE_DISABLE &&
|
|
val != AddonManager.AUTOUPDATE_ENABLE) {
|
|
val = val ? AddonManager.AUTOUPDATE_DEFAULT :
|
|
AddonManager.AUTOUPDATE_DISABLE;
|
|
}
|
|
|
|
if (val == aAddon.applyBackgroundUpdates)
|
|
return val;
|
|
|
|
XPIDatabase.setAddonProperties(aAddon, {
|
|
applyBackgroundUpdates: val
|
|
});
|
|
AddonManagerPrivate.callAddonListeners("onPropertyChanged", this, ["applyBackgroundUpdates"]);
|
|
|
|
return val;
|
|
});
|
|
|
|
this.__defineSetter__("syncGUID", function AddonWrapper_syncGUIDGetter(val) {
|
|
if (aAddon.syncGUID == val)
|
|
return val;
|
|
|
|
if (aAddon.inDatabase)
|
|
XPIDatabase.setAddonSyncGUID(aAddon, val);
|
|
|
|
aAddon.syncGUID = val;
|
|
|
|
return val;
|
|
});
|
|
|
|
this.__defineGetter__("install", function AddonWrapper_installGetter() {
|
|
if (!("_install" in aAddon) || !aAddon._install)
|
|
return null;
|
|
return aAddon._install.wrapper;
|
|
});
|
|
|
|
this.__defineGetter__("pendingUpgrade", function AddonWrapper_pendingUpgradeGetter() {
|
|
return createWrapper(aAddon.pendingUpgrade);
|
|
});
|
|
|
|
this.__defineGetter__("scope", function AddonWrapper_scopeGetter() {
|
|
if (aAddon._installLocation)
|
|
return aAddon._installLocation.scope;
|
|
|
|
return AddonManager.SCOPE_PROFILE;
|
|
});
|
|
|
|
this.__defineGetter__("pendingOperations", function AddonWrapper_pendingOperationsGetter() {
|
|
let pending = 0;
|
|
if (!(aAddon.inDatabase)) {
|
|
// Add-on is pending install if there is no associated install (shouldn't
|
|
// happen here) or if the install is in the process of or has successfully
|
|
// completed the install. If an add-on is pending install then we ignore
|
|
// any other pending operations.
|
|
if (!aAddon._install || aAddon._install.state == AddonManager.STATE_INSTALLING ||
|
|
aAddon._install.state == AddonManager.STATE_INSTALLED)
|
|
return AddonManager.PENDING_INSTALL;
|
|
}
|
|
else if (aAddon.pendingUninstall) {
|
|
// If an add-on is pending uninstall then we ignore any other pending
|
|
// operations
|
|
return AddonManager.PENDING_UNINSTALL;
|
|
}
|
|
|
|
// Extensions have an intentional inconsistency between what the DB says is
|
|
// enabled and what we say to the ouside world. so we need to cover up that
|
|
// lie here as well.
|
|
if (aAddon.type != "experiment") {
|
|
if (aAddon.active && aAddon.disabled)
|
|
pending |= AddonManager.PENDING_DISABLE;
|
|
else if (!aAddon.active && !aAddon.disabled)
|
|
pending |= AddonManager.PENDING_ENABLE;
|
|
}
|
|
|
|
if (aAddon.pendingUpgrade)
|
|
pending |= AddonManager.PENDING_UPGRADE;
|
|
|
|
return pending;
|
|
});
|
|
|
|
this.__defineGetter__("operationsRequiringRestart", function AddonWrapper_operationsRequiringRestartGetter() {
|
|
let ops = 0;
|
|
if (XPIProvider.installRequiresRestart(aAddon))
|
|
ops |= AddonManager.OP_NEEDS_RESTART_INSTALL;
|
|
if (XPIProvider.uninstallRequiresRestart(aAddon))
|
|
ops |= AddonManager.OP_NEEDS_RESTART_UNINSTALL;
|
|
if (XPIProvider.enableRequiresRestart(aAddon))
|
|
ops |= AddonManager.OP_NEEDS_RESTART_ENABLE;
|
|
if (XPIProvider.disableRequiresRestart(aAddon))
|
|
ops |= AddonManager.OP_NEEDS_RESTART_DISABLE;
|
|
|
|
return ops;
|
|
});
|
|
|
|
this.__defineGetter__("isDebuggable", function AddonWrapper_isDebuggable() {
|
|
return this.isActive && aAddon.bootstrap;
|
|
});
|
|
|
|
this.__defineGetter__("permissions", function AddonWrapper_permisionsGetter() {
|
|
return aAddon.permissions();
|
|
});
|
|
|
|
this.__defineGetter__("isActive", function AddonWrapper_isActiveGetter() {
|
|
if (Services.appinfo.inSafeMode)
|
|
return false;
|
|
return aAddon.active;
|
|
});
|
|
|
|
this.__defineGetter__("userDisabled", function AddonWrapper_userDisabledGetter() {
|
|
if (XPIProvider._enabledExperiments.has(aAddon.id)) {
|
|
return false;
|
|
}
|
|
|
|
return aAddon.softDisabled || aAddon.userDisabled;
|
|
});
|
|
this.__defineSetter__("userDisabled", function AddonWrapper_userDisabledSetter(val) {
|
|
if (val == this.userDisabled) {
|
|
return val;
|
|
}
|
|
|
|
if (aAddon.type == "experiment") {
|
|
if (val) {
|
|
XPIProvider._enabledExperiments.delete(aAddon.id);
|
|
} else {
|
|
XPIProvider._enabledExperiments.add(aAddon.id);
|
|
}
|
|
}
|
|
|
|
if (aAddon.inDatabase) {
|
|
if (aAddon.type == "theme" && val) {
|
|
if (aAddon.internalName == XPIProvider.defaultSkin)
|
|
throw new Error("Cannot disable the default theme");
|
|
XPIProvider.enableDefaultTheme();
|
|
}
|
|
else {
|
|
XPIProvider.updateAddonDisabledState(aAddon, val);
|
|
}
|
|
}
|
|
else {
|
|
aAddon.userDisabled = val;
|
|
// When enabling remove the softDisabled flag
|
|
if (!val)
|
|
aAddon.softDisabled = false;
|
|
}
|
|
|
|
return val;
|
|
});
|
|
|
|
this.__defineSetter__("softDisabled", function AddonWrapper_softDisabledSetter(val) {
|
|
if (val == aAddon.softDisabled)
|
|
return val;
|
|
|
|
if (aAddon.inDatabase) {
|
|
// When softDisabling a theme just enable the active theme
|
|
if (aAddon.type == "theme" && val && !aAddon.userDisabled) {
|
|
if (aAddon.internalName == XPIProvider.defaultSkin)
|
|
throw new Error("Cannot disable the default theme");
|
|
XPIProvider.enableDefaultTheme();
|
|
}
|
|
else {
|
|
XPIProvider.updateAddonDisabledState(aAddon, undefined, val);
|
|
}
|
|
}
|
|
else {
|
|
// Only set softDisabled if not already disabled
|
|
if (!aAddon.userDisabled)
|
|
aAddon.softDisabled = val;
|
|
}
|
|
|
|
return val;
|
|
});
|
|
|
|
this.isCompatibleWith = function AddonWrapper_isCompatiblewith(aAppVersion, aPlatformVersion) {
|
|
return aAddon.isCompatibleWith(aAppVersion, aPlatformVersion);
|
|
};
|
|
|
|
this.uninstall = function AddonWrapper_uninstall(alwaysAllowUndo) {
|
|
XPIProvider.uninstallAddon(aAddon, alwaysAllowUndo);
|
|
};
|
|
|
|
this.cancelUninstall = function AddonWrapper_cancelUninstall() {
|
|
XPIProvider.cancelUninstallAddon(aAddon);
|
|
};
|
|
|
|
this.findUpdates = function AddonWrapper_findUpdates(aListener, aReason, aAppVersion, aPlatformVersion) {
|
|
// Short-circuit updates for experiments because updates are handled
|
|
// through the Experiments Manager.
|
|
if (this.type == "experiment") {
|
|
AddonManagerPrivate.callNoUpdateListeners(this, aListener, aReason,
|
|
aAppVersion, aPlatformVersion);
|
|
return;
|
|
}
|
|
|
|
new UpdateChecker(aAddon, aListener, aReason, aAppVersion, aPlatformVersion);
|
|
};
|
|
|
|
// Returns true if there was an update in progress, false if there was no update to cancel
|
|
this.cancelUpdate = function AddonWrapper_cancelUpdate() {
|
|
if (aAddon._updateCheck) {
|
|
aAddon._updateCheck.cancel();
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
this.hasResource = function AddonWrapper_hasResource(aPath) {
|
|
if (aAddon._hasResourceCache.has(aPath))
|
|
return aAddon._hasResourceCache.get(aPath);
|
|
|
|
let bundle = aAddon._sourceBundle.clone();
|
|
|
|
// Bundle may not exist any more if the addon has just been uninstalled,
|
|
// but explicitly first checking .exists() results in unneeded file I/O.
|
|
try {
|
|
var isDir = bundle.isDirectory();
|
|
} catch (e) {
|
|
aAddon._hasResourceCache.set(aPath, false);
|
|
return false;
|
|
}
|
|
|
|
if (isDir) {
|
|
if (aPath) {
|
|
aPath.split("/").forEach(function(aPart) {
|
|
bundle.append(aPart);
|
|
});
|
|
}
|
|
let result = bundle.exists();
|
|
aAddon._hasResourceCache.set(aPath, result);
|
|
return result;
|
|
}
|
|
|
|
let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
|
|
createInstance(Ci.nsIZipReader);
|
|
try {
|
|
zipReader.open(bundle);
|
|
let result = zipReader.hasEntry(aPath);
|
|
aAddon._hasResourceCache.set(aPath, result);
|
|
return result;
|
|
}
|
|
catch (e) {
|
|
aAddon._hasResourceCache.set(aPath, false);
|
|
return false;
|
|
}
|
|
finally {
|
|
zipReader.close();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Returns a URI to the selected resource or to the add-on bundle if aPath
|
|
* is null. URIs to the bundle will always be file: URIs. URIs to resources
|
|
* will be file: URIs if the add-on is unpacked or jar: URIs if the add-on is
|
|
* still an XPI file.
|
|
*
|
|
* @param aPath
|
|
* The path in the add-on to get the URI for or null to get a URI to
|
|
* the file or directory the add-on is installed as.
|
|
* @return an nsIURI
|
|
*/
|
|
this.getResourceURI = function AddonWrapper_getResourceURI(aPath) {
|
|
if (!aPath)
|
|
return NetUtil.newURI(aAddon._sourceBundle);
|
|
|
|
return getURIForResourceInFile(aAddon._sourceBundle, aPath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* An object which identifies a directory install location for add-ons. The
|
|
* location consists of a directory which contains the add-ons installed in the
|
|
* location.
|
|
*
|
|
* Each add-on installed in the location is either a directory containing the
|
|
* add-on's files or a text file containing an absolute path to the directory
|
|
* containing the add-ons files. The directory or text file must have the same
|
|
* name as the add-on's ID.
|
|
*
|
|
* There may also a special directory named "staged" which can contain
|
|
* directories with the same name as an add-on ID. If the directory is empty
|
|
* then it means the add-on will be uninstalled from this location during the
|
|
* next startup. If the directory contains the add-on's files then they will be
|
|
* installed during the next startup.
|
|
*
|
|
* @param aName
|
|
* The string identifier for the install location
|
|
* @param aDirectory
|
|
* The nsIFile directory for the install location
|
|
* @param aScope
|
|
* The scope of add-ons installed in this location
|
|
* @param aLocked
|
|
* true if add-ons cannot be installed, uninstalled or upgraded in the
|
|
* install location
|
|
*/
|
|
function DirectoryInstallLocation(aName, aDirectory, aScope, aLocked) {
|
|
this._name = aName;
|
|
this.locked = aLocked;
|
|
this._directory = aDirectory;
|
|
this._scope = aScope
|
|
this._IDToFileMap = {};
|
|
this._FileToIDMap = {};
|
|
this._linkedAddons = [];
|
|
this._stagingDirLock = 0;
|
|
|
|
if (!aDirectory.exists())
|
|
return;
|
|
if (!aDirectory.isDirectory())
|
|
throw new Error("Location must be a directory.");
|
|
|
|
this._readAddons();
|
|
}
|
|
|
|
DirectoryInstallLocation.prototype = {
|
|
_name : "",
|
|
_directory : null,
|
|
_IDToFileMap : null, // mapping from add-on ID to nsIFile
|
|
_FileToIDMap : null, // mapping from add-on path to add-on ID
|
|
|
|
/**
|
|
* Reads a directory linked to in a file.
|
|
*
|
|
* @param file
|
|
* The file containing the directory path
|
|
* @return An nsIFile object representing the linked directory.
|
|
*/
|
|
_readDirectoryFromFile: function DirInstallLocation__readDirectoryFromFile(aFile) {
|
|
let fis = Cc["@mozilla.org/network/file-input-stream;1"].
|
|
createInstance(Ci.nsIFileInputStream);
|
|
fis.init(aFile, -1, -1, false);
|
|
let line = { value: "" };
|
|
if (fis instanceof Ci.nsILineInputStream)
|
|
fis.readLine(line);
|
|
fis.close();
|
|
if (line.value) {
|
|
let linkedDirectory = Cc["@mozilla.org/file/local;1"].
|
|
createInstance(Ci.nsIFile);
|
|
|
|
try {
|
|
linkedDirectory.initWithPath(line.value);
|
|
}
|
|
catch (e) {
|
|
linkedDirectory.setRelativeDescriptor(aFile.parent, line.value);
|
|
}
|
|
|
|
if (!linkedDirectory.exists()) {
|
|
logger.warn("File pointer " + aFile.path + " points to " + linkedDirectory.path +
|
|
" which does not exist");
|
|
return null;
|
|
}
|
|
|
|
if (!linkedDirectory.isDirectory()) {
|
|
logger.warn("File pointer " + aFile.path + " points to " + linkedDirectory.path +
|
|
" which is not a directory");
|
|
return null;
|
|
}
|
|
|
|
return linkedDirectory;
|
|
}
|
|
|
|
logger.warn("File pointer " + aFile.path + " does not contain a path");
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Finds all the add-ons installed in this location.
|
|
*/
|
|
_readAddons: function DirInstallLocation__readAddons() {
|
|
// Use a snapshot of the directory contents to avoid possible issues with
|
|
// iterating over a directory while removing files from it (the YAFFS2
|
|
// embedded filesystem has this issue, see bug 772238).
|
|
let entries = getDirectoryEntries(this._directory);
|
|
for (let entry of entries) {
|
|
let id = entry.leafName;
|
|
|
|
if (id == DIR_STAGE || id == DIR_XPI_STAGE || id == DIR_TRASH)
|
|
continue;
|
|
|
|
let directLoad = false;
|
|
if (entry.isFile() &&
|
|
id.substring(id.length - 4).toLowerCase() == ".xpi") {
|
|
directLoad = true;
|
|
id = id.substring(0, id.length - 4);
|
|
}
|
|
|
|
if (!gIDTest.test(id)) {
|
|
logger.debug("Ignoring file entry whose name is not a valid add-on ID: " +
|
|
entry.path);
|
|
continue;
|
|
}
|
|
|
|
if (entry.isFile() && !directLoad) {
|
|
let newEntry = this._readDirectoryFromFile(entry);
|
|
if (!newEntry) {
|
|
logger.debug("Deleting stale pointer file " + entry.path);
|
|
try {
|
|
entry.remove(true);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to remove stale pointer file " + entry.path, e);
|
|
// Failing to remove the stale pointer file is ignorable
|
|
}
|
|
continue;
|
|
}
|
|
|
|
entry = newEntry;
|
|
this._linkedAddons.push(id);
|
|
}
|
|
|
|
this._IDToFileMap[id] = entry;
|
|
this._FileToIDMap[entry.path] = id;
|
|
XPIProvider._addURIMapping(id, entry);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Gets the name of this install location.
|
|
*/
|
|
get name() {
|
|
return this._name;
|
|
},
|
|
|
|
/**
|
|
* Gets the scope of this install location.
|
|
*/
|
|
get scope() {
|
|
return this._scope;
|
|
},
|
|
|
|
/**
|
|
* Gets an array of nsIFiles for add-ons installed in this location.
|
|
*/
|
|
get addonLocations() {
|
|
let locations = [];
|
|
for (let id in this._IDToFileMap) {
|
|
locations.push(this._IDToFileMap[id].clone());
|
|
}
|
|
return locations;
|
|
},
|
|
|
|
/**
|
|
* Gets the staging directory to put add-ons that are pending install and
|
|
* uninstall into.
|
|
*
|
|
* @return an nsIFile
|
|
*/
|
|
getStagingDir: function DirInstallLocation_getStagingDir() {
|
|
let dir = this._directory.clone();
|
|
dir.append(DIR_STAGE);
|
|
return dir;
|
|
},
|
|
|
|
requestStagingDir: function() {
|
|
this._stagingDirLock++;
|
|
|
|
if (this._stagingDirPromise)
|
|
return this._stagingDirPromise;
|
|
|
|
OS.File.makeDir(this._directory.path);
|
|
let stagepath = OS.Path.join(this._directory.path, DIR_STAGE);
|
|
return this._stagingDirPromise = OS.File.makeDir(stagepath).then(null, (e) => {
|
|
if (e instanceof OS.File.Error && e.becauseExists)
|
|
return;
|
|
logger.error("Failed to create staging directory", e);
|
|
throw e;
|
|
});
|
|
},
|
|
|
|
releaseStagingDir: function() {
|
|
this._stagingDirLock--;
|
|
|
|
if (this._stagingDirLock == 0) {
|
|
this._stagingDirPromise = null;
|
|
this.cleanStagingDir();
|
|
}
|
|
|
|
return Promise.resolve();
|
|
},
|
|
|
|
/**
|
|
* Removes the specified files or directories in the staging directory and
|
|
* then if the staging directory is empty attempts to remove it.
|
|
*
|
|
* @param aLeafNames
|
|
* An array of file or directory to remove from the directory, the
|
|
* array may be empty
|
|
*/
|
|
cleanStagingDir: function(aLeafNames = []) {
|
|
let dir = this.getStagingDir();
|
|
|
|
for (let name of aLeafNames) {
|
|
let file = dir.clone();
|
|
file.append(name);
|
|
recursiveRemove(file);
|
|
}
|
|
|
|
if (this._stagingDirLock > 0)
|
|
return;
|
|
|
|
let dirEntries = dir.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator);
|
|
try {
|
|
if (dirEntries.nextFile)
|
|
return;
|
|
}
|
|
finally {
|
|
dirEntries.close();
|
|
}
|
|
|
|
try {
|
|
setFilePermissions(dir, FileUtils.PERMS_DIRECTORY);
|
|
dir.remove(false);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to remove staging dir", e);
|
|
// Failing to remove the staging directory is ignorable
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Gets the directory used by old versions for staging XPI and JAR files ready
|
|
* to be installed.
|
|
*
|
|
* @return an nsIFile
|
|
*/
|
|
getXPIStagingDir: function DirInstallLocation_getXPIStagingDir() {
|
|
let dir = this._directory.clone();
|
|
dir.append(DIR_XPI_STAGE);
|
|
return dir;
|
|
},
|
|
|
|
/**
|
|
* Returns a directory that is normally on the same filesystem as the rest of
|
|
* the install location and can be used for temporarily storing files during
|
|
* safe move operations. Calling this method will delete the existing trash
|
|
* directory and its contents.
|
|
*
|
|
* @return an nsIFile
|
|
*/
|
|
getTrashDir: function DirInstallLocation_getTrashDir() {
|
|
let trashDir = this._directory.clone();
|
|
trashDir.append(DIR_TRASH);
|
|
let trashDirExists = trashDir.exists();
|
|
try {
|
|
if (trashDirExists)
|
|
recursiveRemove(trashDir);
|
|
trashDirExists = false;
|
|
} catch (e) {
|
|
logger.warn("Failed to remove trash directory", e);
|
|
}
|
|
if (!trashDirExists)
|
|
trashDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY);
|
|
return trashDir;
|
|
},
|
|
|
|
/**
|
|
* Installs an add-on into the install location.
|
|
*
|
|
* @param aId
|
|
* The ID of the add-on to install
|
|
* @param aSource
|
|
* The source nsIFile to install from
|
|
* @param aExistingAddonID
|
|
* The ID of an existing add-on to uninstall at the same time
|
|
* @param aCopy
|
|
* If false the source files will be moved to the new location,
|
|
* otherwise they will only be copied
|
|
* @return an nsIFile indicating where the add-on was installed to
|
|
*/
|
|
installAddon: function DirInstallLocation_installAddon(aId, aSource,
|
|
aExistingAddonID,
|
|
aCopy) {
|
|
let trashDir = this.getTrashDir();
|
|
|
|
let transaction = new SafeInstallOperation();
|
|
|
|
let self = this;
|
|
function moveOldAddon(aId) {
|
|
let file = self._directory.clone();
|
|
file.append(aId);
|
|
|
|
if (file.exists())
|
|
transaction.moveUnder(file, trashDir);
|
|
|
|
file = self._directory.clone();
|
|
file.append(aId + ".xpi");
|
|
if (file.exists()) {
|
|
flushJarCache(file);
|
|
transaction.moveUnder(file, trashDir);
|
|
}
|
|
}
|
|
|
|
// If any of these operations fails the finally block will clean up the
|
|
// temporary directory
|
|
try {
|
|
moveOldAddon(aId);
|
|
if (aExistingAddonID && aExistingAddonID != aId) {
|
|
moveOldAddon(aExistingAddonID);
|
|
|
|
{
|
|
// Move the data directories.
|
|
/* XXX ajvincent We can't use OS.File: installAddon isn't compatible
|
|
* with Promises, nor is SafeInstallOperation. Bug 945540 has been filed
|
|
* for porting to OS.File.
|
|
*/
|
|
let oldDataDir = FileUtils.getDir(
|
|
KEY_PROFILEDIR, ["extension-data", aExistingAddonID], false, true
|
|
);
|
|
|
|
if (oldDataDir.exists()) {
|
|
let newDataDir = FileUtils.getDir(
|
|
KEY_PROFILEDIR, ["extension-data", aId], false, true
|
|
);
|
|
if (newDataDir.exists()) {
|
|
let trashData = trashDir.clone();
|
|
trashData.append("data-directory");
|
|
transaction.moveUnder(newDataDir, trashData);
|
|
}
|
|
|
|
transaction.moveTo(oldDataDir, newDataDir);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aCopy) {
|
|
transaction.copy(aSource, this._directory);
|
|
}
|
|
else {
|
|
if (aSource.isFile())
|
|
flushJarCache(aSource);
|
|
|
|
transaction.moveUnder(aSource, this._directory);
|
|
}
|
|
}
|
|
finally {
|
|
// It isn't ideal if this cleanup fails but it isn't worth rolling back
|
|
// the install because of it.
|
|
try {
|
|
recursiveRemove(trashDir);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to remove trash directory when installing " + aId, e);
|
|
}
|
|
}
|
|
|
|
let newFile = this._directory.clone();
|
|
newFile.append(aSource.leafName);
|
|
try {
|
|
newFile.lastModifiedTime = Date.now();
|
|
} catch (e) {
|
|
logger.warn("failed to set lastModifiedTime on " + newFile.path, e);
|
|
}
|
|
this._FileToIDMap[newFile.path] = aId;
|
|
this._IDToFileMap[aId] = newFile;
|
|
XPIProvider._addURIMapping(aId, newFile);
|
|
|
|
if (aExistingAddonID && aExistingAddonID != aId &&
|
|
aExistingAddonID in this._IDToFileMap) {
|
|
delete this._FileToIDMap[this._IDToFileMap[aExistingAddonID]];
|
|
delete this._IDToFileMap[aExistingAddonID];
|
|
}
|
|
|
|
return newFile;
|
|
},
|
|
|
|
/**
|
|
* Uninstalls an add-on from this location.
|
|
*
|
|
* @param aId
|
|
* The ID of the add-on to uninstall
|
|
* @throws if the ID does not match any of the add-ons installed
|
|
*/
|
|
uninstallAddon: function DirInstallLocation_uninstallAddon(aId) {
|
|
let file = this._IDToFileMap[aId];
|
|
if (!file) {
|
|
logger.warn("Attempted to remove " + aId + " from " +
|
|
this._name + " but it was already gone");
|
|
return;
|
|
}
|
|
|
|
file = this._directory.clone();
|
|
file.append(aId);
|
|
if (!file.exists())
|
|
file.leafName += ".xpi";
|
|
|
|
if (!file.exists()) {
|
|
logger.warn("Attempted to remove " + aId + " from " +
|
|
this._name + " but it was already gone");
|
|
|
|
delete this._FileToIDMap[file.path];
|
|
delete this._IDToFileMap[aId];
|
|
return;
|
|
}
|
|
|
|
let trashDir = this.getTrashDir();
|
|
|
|
if (file.leafName != aId) {
|
|
logger.debug("uninstallAddon: flushing jar cache " + file.path + " for addon " + aId);
|
|
flushJarCache(file);
|
|
}
|
|
|
|
let transaction = new SafeInstallOperation();
|
|
|
|
try {
|
|
transaction.moveUnder(file, trashDir);
|
|
}
|
|
finally {
|
|
// It isn't ideal if this cleanup fails, but it is probably better than
|
|
// rolling back the uninstall at this point
|
|
try {
|
|
recursiveRemove(trashDir);
|
|
}
|
|
catch (e) {
|
|
logger.warn("Failed to remove trash directory when uninstalling " + aId, e);
|
|
}
|
|
}
|
|
|
|
delete this._FileToIDMap[file.path];
|
|
delete this._IDToFileMap[aId];
|
|
},
|
|
|
|
/**
|
|
* Gets the ID of the add-on installed in the given nsIFile.
|
|
*
|
|
* @param aFile
|
|
* The nsIFile to look in
|
|
* @return the ID
|
|
* @throws if the file does not represent an installed add-on
|
|
*/
|
|
getIDForLocation: function DirInstallLocation_getIDForLocation(aFile) {
|
|
if (aFile.path in this._FileToIDMap)
|
|
return this._FileToIDMap[aFile.path];
|
|
throw new Error("Unknown add-on location " + aFile.path);
|
|
},
|
|
|
|
/**
|
|
* Gets the directory that the add-on with the given ID is installed in.
|
|
*
|
|
* @param aId
|
|
* The ID of the add-on
|
|
* @return The nsIFile
|
|
* @throws if the ID does not match any of the add-ons installed
|
|
*/
|
|
getLocationForID: function DirInstallLocation_getLocationForID(aId) {
|
|
if (aId in this._IDToFileMap)
|
|
return this._IDToFileMap[aId].clone();
|
|
throw new Error("Unknown add-on ID " + aId);
|
|
},
|
|
|
|
/**
|
|
* Returns true if the given addon was installed in this location by a text
|
|
* file pointing to its real path.
|
|
*
|
|
* @param aId
|
|
* The ID of the addon
|
|
*/
|
|
isLinkedAddon: function DirInstallLocation__isLinkedAddon(aId) {
|
|
return this._linkedAddons.indexOf(aId) != -1;
|
|
}
|
|
};
|
|
|
|
#ifdef XP_WIN
|
|
/**
|
|
* An object that identifies a registry install location for add-ons. The location
|
|
* consists of a registry key which contains string values mapping ID to the
|
|
* path where an add-on is installed
|
|
*
|
|
* @param aName
|
|
* The string identifier of this Install Location.
|
|
* @param aRootKey
|
|
* The root key (one of the ROOT_KEY_ values from nsIWindowsRegKey).
|
|
* @param scope
|
|
* The scope of add-ons installed in this location
|
|
*/
|
|
function WinRegInstallLocation(aName, aRootKey, aScope) {
|
|
this.locked = true;
|
|
this._name = aName;
|
|
this._rootKey = aRootKey;
|
|
this._scope = aScope;
|
|
this._IDToFileMap = {};
|
|
this._FileToIDMap = {};
|
|
|
|
let path = this._appKeyPath + "\\Extensions";
|
|
let key = Cc["@mozilla.org/windows-registry-key;1"].
|
|
createInstance(Ci.nsIWindowsRegKey);
|
|
|
|
// Reading the registry may throw an exception, and that's ok. In error
|
|
// cases, we just leave ourselves in the empty state.
|
|
try {
|
|
key.open(this._rootKey, path, Ci.nsIWindowsRegKey.ACCESS_READ);
|
|
}
|
|
catch (e) {
|
|
return;
|
|
}
|
|
|
|
this._readAddons(key);
|
|
key.close();
|
|
}
|
|
|
|
WinRegInstallLocation.prototype = {
|
|
_name : "",
|
|
_rootKey : null,
|
|
_scope : null,
|
|
_IDToFileMap : null, // mapping from ID to nsIFile
|
|
_FileToIDMap : null, // mapping from path to ID
|
|
|
|
/**
|
|
* Retrieves the path of this Application's data key in the registry.
|
|
*/
|
|
get _appKeyPath() {
|
|
let appVendor = Services.appinfo.vendor;
|
|
let appName = Services.appinfo.name;
|
|
|
|
#ifdef MOZ_THUNDERBIRD
|
|
// XXX Thunderbird doesn't specify a vendor string
|
|
if (appVendor == "")
|
|
appVendor = "Mozilla";
|
|
#endif
|
|
|
|
// XULRunner-based apps may intentionally not specify a vendor
|
|
if (appVendor != "")
|
|
appVendor += "\\";
|
|
|
|
return "SOFTWARE\\" + appVendor + appName;
|
|
},
|
|
|
|
/**
|
|
* Read the registry and build a mapping between ID and path for each
|
|
* installed add-on.
|
|
*
|
|
* @param key
|
|
* The key that contains the ID to path mapping
|
|
*/
|
|
_readAddons: function RegInstallLocation__readAddons(aKey) {
|
|
let count = aKey.valueCount;
|
|
for (let i = 0; i < count; ++i) {
|
|
let id = aKey.getValueName(i);
|
|
|
|
let file = Cc["@mozilla.org/file/local;1"].
|
|
createInstance(Ci.nsIFile);
|
|
file.initWithPath(aKey.readStringValue(id));
|
|
|
|
if (!file.exists()) {
|
|
logger.warn("Ignoring missing add-on in " + file.path);
|
|
continue;
|
|
}
|
|
|
|
this._IDToFileMap[id] = file;
|
|
this._FileToIDMap[file.path] = id;
|
|
XPIProvider._addURIMapping(id, file);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Gets the name of this install location.
|
|
*/
|
|
get name() {
|
|
return this._name;
|
|
},
|
|
|
|
/**
|
|
* Gets the scope of this install location.
|
|
*/
|
|
get scope() {
|
|
return this._scope;
|
|
},
|
|
|
|
/**
|
|
* Gets an array of nsIFiles for add-ons installed in this location.
|
|
*/
|
|
get addonLocations() {
|
|
let locations = [];
|
|
for (let id in this._IDToFileMap) {
|
|
locations.push(this._IDToFileMap[id].clone());
|
|
}
|
|
return locations;
|
|
},
|
|
|
|
/**
|
|
* Gets the ID of the add-on installed in the given nsIFile.
|
|
*
|
|
* @param aFile
|
|
* The nsIFile to look in
|
|
* @return the ID
|
|
* @throws if the file does not represent an installed add-on
|
|
*/
|
|
getIDForLocation: function RegInstallLocation_getIDForLocation(aFile) {
|
|
if (aFile.path in this._FileToIDMap)
|
|
return this._FileToIDMap[aFile.path];
|
|
throw new Error("Unknown add-on location");
|
|
},
|
|
|
|
/**
|
|
* Gets the nsIFile that the add-on with the given ID is installed in.
|
|
*
|
|
* @param aId
|
|
* The ID of the add-on
|
|
* @return the nsIFile
|
|
*/
|
|
getLocationForID: function RegInstallLocation_getLocationForID(aId) {
|
|
if (aId in this._IDToFileMap)
|
|
return this._IDToFileMap[aId].clone();
|
|
throw new Error("Unknown add-on ID");
|
|
},
|
|
|
|
/**
|
|
* @see DirectoryInstallLocation
|
|
*/
|
|
isLinkedAddon: function RegInstallLocation_isLinkedAddon(aId) {
|
|
return true;
|
|
}
|
|
};
|
|
#endif
|
|
|
|
var addonTypes = [
|
|
new AddonManagerPrivate.AddonType("extension", URI_EXTENSION_STRINGS,
|
|
STRING_TYPE_NAME,
|
|
AddonManager.VIEW_TYPE_LIST, 4000,
|
|
AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL),
|
|
new AddonManagerPrivate.AddonType("theme", URI_EXTENSION_STRINGS,
|
|
STRING_TYPE_NAME,
|
|
AddonManager.VIEW_TYPE_LIST, 5000),
|
|
new AddonManagerPrivate.AddonType("dictionary", URI_EXTENSION_STRINGS,
|
|
STRING_TYPE_NAME,
|
|
AddonManager.VIEW_TYPE_LIST, 7000,
|
|
AddonManager.TYPE_UI_HIDE_EMPTY | AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL),
|
|
new AddonManagerPrivate.AddonType("locale", URI_EXTENSION_STRINGS,
|
|
STRING_TYPE_NAME,
|
|
AddonManager.VIEW_TYPE_LIST, 8000,
|
|
AddonManager.TYPE_UI_HIDE_EMPTY | AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL),
|
|
];
|
|
|
|
// We only register experiments support if the application supports them.
|
|
// Ideally, we would install an observer to watch the pref. Installing
|
|
// an observer for this pref is not necessary here and may be buggy with
|
|
// regards to registering this XPIProvider twice.
|
|
if (Preferences.get("experiments.supported", false)) {
|
|
addonTypes.push(
|
|
new AddonManagerPrivate.AddonType("experiment",
|
|
URI_EXTENSION_STRINGS,
|
|
STRING_TYPE_NAME,
|
|
AddonManager.VIEW_TYPE_LIST, 11000,
|
|
AddonManager.TYPE_UI_HIDE_EMPTY | AddonManager.TYPE_SUPPORTS_UNDO_RESTARTLESS_UNINSTALL));
|
|
}
|
|
|
|
AddonManagerPrivate.registerProvider(XPIProvider, addonTypes);
|