From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- .../extensions/internal/APIExtensionBootstrap.js | 39 + .../mozapps/extensions/internal/AddonConstants.jsm | 31 + .../mozapps/extensions/internal/AddonLogging.jsm | 192 + .../extensions/internal/AddonRepository.jsm | 1988 +++++ .../internal/AddonRepository_SQLiteMigrator.jsm | 522 ++ .../mozapps/extensions/internal/AddonTestUtils.jsm | 1232 +++ .../extensions/internal/AddonUpdateChecker.jsm | 934 ++ toolkit/mozapps/extensions/internal/Content.js | 38 + .../extensions/internal/E10SAddonsRollout.jsm | 982 +++ .../mozapps/extensions/internal/GMPProvider.jsm | 699 ++ .../internal/LightweightThemeImageOptimizer.jsm | 180 + .../mozapps/extensions/internal/PluginProvider.jsm | 600 ++ .../extensions/internal/ProductAddonChecker.jsm | 467 + .../internal/SpellCheckDictionaryBootstrap.js | 17 + .../extensions/internal/WebExtensionBootstrap.js | 39 + .../mozapps/extensions/internal/XPIProvider.jsm | 9305 ++++++++++++++++++++ .../extensions/internal/XPIProviderUtils.js | 2255 +++++ toolkit/mozapps/extensions/internal/moz.build | 36 + 18 files changed, 19556 insertions(+) create mode 100644 toolkit/mozapps/extensions/internal/APIExtensionBootstrap.js create mode 100644 toolkit/mozapps/extensions/internal/AddonConstants.jsm create mode 100644 toolkit/mozapps/extensions/internal/AddonLogging.jsm create mode 100644 toolkit/mozapps/extensions/internal/AddonRepository.jsm create mode 100644 toolkit/mozapps/extensions/internal/AddonRepository_SQLiteMigrator.jsm create mode 100644 toolkit/mozapps/extensions/internal/AddonTestUtils.jsm create mode 100644 toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm create mode 100644 toolkit/mozapps/extensions/internal/Content.js create mode 100644 toolkit/mozapps/extensions/internal/E10SAddonsRollout.jsm create mode 100644 toolkit/mozapps/extensions/internal/GMPProvider.jsm create mode 100644 toolkit/mozapps/extensions/internal/LightweightThemeImageOptimizer.jsm create mode 100644 toolkit/mozapps/extensions/internal/PluginProvider.jsm create mode 100644 toolkit/mozapps/extensions/internal/ProductAddonChecker.jsm create mode 100644 toolkit/mozapps/extensions/internal/SpellCheckDictionaryBootstrap.js create mode 100644 toolkit/mozapps/extensions/internal/WebExtensionBootstrap.js create mode 100644 toolkit/mozapps/extensions/internal/XPIProvider.jsm create mode 100644 toolkit/mozapps/extensions/internal/XPIProviderUtils.js create mode 100644 toolkit/mozapps/extensions/internal/moz.build (limited to 'toolkit/mozapps/extensions/internal') diff --git a/toolkit/mozapps/extensions/internal/APIExtensionBootstrap.js b/toolkit/mozapps/extensions/internal/APIExtensionBootstrap.js new file mode 100644 index 0000000000..0eae2475c4 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/APIExtensionBootstrap.js @@ -0,0 +1,39 @@ +/* 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"; + +Components.utils.import("resource://gre/modules/ExtensionManagement.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +var namespace; +var resource; +var resProto; + +function install(data, reason) { +} + +function startup(data, reason) { + namespace = data.id.replace(/@.*/, ""); + resource = `extension-${namespace}-api`; + + resProto = Services.io.getProtocolHandler("resource") + .QueryInterface(Components.interfaces.nsIResProtocolHandler); + + resProto.setSubstitution(resource, data.resourceURI); + + ExtensionManagement.registerAPI( + namespace, + `resource://${resource}/schema.json`, + `resource://${resource}/api.js`); +} + +function shutdown(data, reason) { + resProto.setSubstitution(resource, null); + + ExtensionManagement.unregisterAPI(namespace); +} + +function uninstall(data, reason) { +} diff --git a/toolkit/mozapps/extensions/internal/AddonConstants.jsm b/toolkit/mozapps/extensions/internal/AddonConstants.jsm new file mode 100644 index 0000000000..22d91fdf5b --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonConstants.jsm @@ -0,0 +1,31 @@ +/* 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"; + +this.EXPORTED_SYMBOLS = [ "ADDON_SIGNING", "REQUIRE_SIGNING" ]; + +// Make these non-changable properties so they can't be manipulated from other +// code in the app. +Object.defineProperty(this, "ADDON_SIGNING", { + configurable: false, + enumerable: false, + writable: false, +#ifdef MOZ_ADDON_SIGNING + value: true, +#else + value: false, +#endif +}); + +Object.defineProperty(this, "REQUIRE_SIGNING", { + configurable: false, + enumerable: false, + writable: false, +#ifdef MOZ_REQUIRE_SIGNING + value: true, +#else + value: false, +#endif +}); diff --git a/toolkit/mozapps/extensions/internal/AddonLogging.jsm b/toolkit/mozapps/extensions/internal/AddonLogging.jsm new file mode 100644 index 0000000000..f05a6fe6c3 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonLogging.jsm @@ -0,0 +1,192 @@ +/* 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 KEY_PROFILEDIR = "ProfD"; +const FILE_EXTENSIONS_LOG = "extensions.log"; +const PREF_LOGGING_ENABLED = "extensions.logging.enabled"; + +const LOGGER_FILE_PERM = parseInt("666", 8); + +const NS_PREFBRANCH_PREFCHANGE_TOPIC_ID = "nsPref:changed"; + +Components.utils.import("resource://gre/modules/FileUtils.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); + +this.EXPORTED_SYMBOLS = [ "LogManager" ]; + +var gDebugLogEnabled = false; + +function formatLogMessage(aType, aName, aStr, aException) { + let message = aType.toUpperCase() + " " + aName + ": " + aStr; + if (aException) { + if (typeof aException == "number") + return message + ": " + Components.Exception("", aException).name; + + message = message + ": " + aException; + // instanceOf doesn't work here, let's duck type + if (aException.fileName) + message = message + " (" + aException.fileName + ":" + aException.lineNumber + ")"; + + if (aException.message == "too much recursion") + dump(message + "\n" + aException.stack + "\n"); + } + return message; +} + +function getStackDetails(aException) { + // Defensively wrap all this to ensure that failing to get the message source + // doesn't stop the message from being logged + try { + if (aException) { + if (aException instanceof Ci.nsIException) { + return { + sourceName: aException.filename, + lineNumber: aException.lineNumber + }; + } + + if (typeof aException == "object") { + return { + sourceName: aException.fileName, + lineNumber: aException.lineNumber + }; + } + } + + let stackFrame = Components.stack.caller.caller.caller; + return { + sourceName: stackFrame.filename, + lineNumber: stackFrame.lineNumber + }; + } + catch (e) { + return { + sourceName: null, + lineNumber: 0 + }; + } +} + +function AddonLogger(aName) { + this.name = aName; +} + +AddonLogger.prototype = { + name: null, + + error: function(aStr, aException) { + let message = formatLogMessage("error", this.name, aStr, aException); + + let stack = getStackDetails(aException); + + let consoleMessage = Cc["@mozilla.org/scripterror;1"]. + createInstance(Ci.nsIScriptError); + consoleMessage.init(message, stack.sourceName, null, stack.lineNumber, 0, + Ci.nsIScriptError.errorFlag, "component javascript"); + Services.console.logMessage(consoleMessage); + + // Always dump errors, in case the Console Service isn't listening yet + dump("*** " + message + "\n"); + + function formatTimestamp(date) { + // Format timestamp as: "%Y-%m-%d %H:%M:%S" + let year = String(date.getFullYear()); + let month = String(date.getMonth() + 1).padStart(2, "0"); + let day = String(date.getDate()).padStart(2, "0"); + let hours = String(date.getHours()).padStart(2, "0"); + let minutes = String(date.getMinutes()).padStart(2, "0"); + let seconds = String(date.getSeconds()).padStart(2, "0"); + + return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`; + } + + try { + var tstamp = new Date(); + var logfile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_EXTENSIONS_LOG]); + var stream = Cc["@mozilla.org/network/file-output-stream;1"]. + createInstance(Ci.nsIFileOutputStream); + stream.init(logfile, 0x02 | 0x08 | 0x10, LOGGER_FILE_PERM, 0); // write, create, append + var writer = Cc["@mozilla.org/intl/converter-output-stream;1"]. + createInstance(Ci.nsIConverterOutputStream); + writer.init(stream, "UTF-8", 0, 0x0000); + writer.writeString(formatTimestamp(tstamp) + " " + + message + " at " + stack.sourceName + ":" + + stack.lineNumber + "\n"); + writer.close(); + } + catch (e) { } + }, + + warn: function(aStr, aException) { + let message = formatLogMessage("warn", this.name, aStr, aException); + + let stack = getStackDetails(aException); + + let consoleMessage = Cc["@mozilla.org/scripterror;1"]. + createInstance(Ci.nsIScriptError); + consoleMessage.init(message, stack.sourceName, null, stack.lineNumber, 0, + Ci.nsIScriptError.warningFlag, "component javascript"); + Services.console.logMessage(consoleMessage); + + if (gDebugLogEnabled) + dump("*** " + message + "\n"); + }, + + log: function(aStr, aException) { + if (gDebugLogEnabled) { + let message = formatLogMessage("log", this.name, aStr, aException); + dump("*** " + message + "\n"); + Services.console.logStringMessage(message); + } + } +}; + +this.LogManager = { + getLogger: function(aName, aTarget) { + let logger = new AddonLogger(aName); + + if (aTarget) { + ["error", "warn", "log"].forEach(function(name) { + let fname = name.toUpperCase(); + delete aTarget[fname]; + aTarget[fname] = function(aStr, aException) { + logger[name](aStr, aException); + }; + }); + } + + return logger; + } +}; + +var PrefObserver = { + init: function() { + Services.prefs.addObserver(PREF_LOGGING_ENABLED, this, false); + Services.obs.addObserver(this, "xpcom-shutdown", false); + this.observe(null, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, PREF_LOGGING_ENABLED); + }, + + observe: function(aSubject, aTopic, aData) { + if (aTopic == "xpcom-shutdown") { + Services.prefs.removeObserver(PREF_LOGGING_ENABLED, this); + Services.obs.removeObserver(this, "xpcom-shutdown"); + } + else if (aTopic == NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) { + try { + gDebugLogEnabled = Services.prefs.getBoolPref(PREF_LOGGING_ENABLED); + } + catch (e) { + gDebugLogEnabled = false; + } + } + } +}; + +PrefObserver.init(); diff --git a/toolkit/mozapps/extensions/internal/AddonRepository.jsm b/toolkit/mozapps/extensions/internal/AddonRepository.jsm new file mode 100644 index 0000000000..7f88d44ad3 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonRepository.jsm @@ -0,0 +1,1988 @@ +/* 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 Cu = Components.utils; +const Cr = Components.results; + +Components.utils.import("resource://gre/modules/Services.jsm"); +Components.utils.import("resource://gre/modules/AddonManager.jsm"); +/* globals AddonManagerPrivate*/ +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "NetUtil", + "resource://gre/modules/NetUtil.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "OS", + "resource://gre/modules/osfile.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "DeferredSave", + "resource://gre/modules/DeferredSave.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository_SQLiteMigrator", + "resource://gre/modules/addons/AddonRepository_SQLiteMigrator.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Promise", + "resource://gre/modules/Promise.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ServiceRequest", + "resource://gre/modules/ServiceRequest.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Task", + "resource://gre/modules/Task.jsm"); + + +this.EXPORTED_SYMBOLS = [ "AddonRepository" ]; + +const PREF_GETADDONS_CACHE_ENABLED = "extensions.getAddons.cache.enabled"; +const PREF_GETADDONS_CACHE_TYPES = "extensions.getAddons.cache.types"; +const PREF_GETADDONS_CACHE_ID_ENABLED = "extensions.%ID%.getAddons.cache.enabled" +const PREF_GETADDONS_BROWSEADDONS = "extensions.getAddons.browseAddons"; +const PREF_GETADDONS_BYIDS = "extensions.getAddons.get.url"; +const PREF_GETADDONS_BYIDS_PERFORMANCE = "extensions.getAddons.getWithPerformance.url"; +const PREF_GETADDONS_BROWSERECOMMENDED = "extensions.getAddons.recommended.browseURL"; +const PREF_GETADDONS_GETRECOMMENDED = "extensions.getAddons.recommended.url"; +const PREF_GETADDONS_BROWSESEARCHRESULTS = "extensions.getAddons.search.browseURL"; +const PREF_GETADDONS_GETSEARCHRESULTS = "extensions.getAddons.search.url"; +const PREF_GETADDONS_DB_SCHEMA = "extensions.getAddons.databaseSchema" + +const PREF_METADATA_LASTUPDATE = "extensions.getAddons.cache.lastUpdate"; +const PREF_METADATA_UPDATETHRESHOLD_SEC = "extensions.getAddons.cache.updateThreshold"; +const DEFAULT_METADATA_UPDATETHRESHOLD_SEC = 172800; // two days + +const XMLURI_PARSE_ERROR = "http://www.mozilla.org/newlayout/xml/parsererror.xml"; + +const API_VERSION = "1.5"; +const DEFAULT_CACHE_TYPES = "extension,theme,locale,dictionary"; + +const KEY_PROFILEDIR = "ProfD"; +const FILE_DATABASE = "addons.json"; +const DB_SCHEMA = 5; +const DB_MIN_JSON_SCHEMA = 5; +const DB_BATCH_TIMEOUT_MS = 50; + +const BLANK_DB = function() { + return { + addons: new Map(), + schema: DB_SCHEMA + }; +} + +const TOOLKIT_ID = "toolkit@mozilla.org"; + +Cu.import("resource://gre/modules/Log.jsm"); +const LOGGER_ID = "addons.repository"; + +// Create a new logger for use by the Addons Repository +// (Requires AddonManager.jsm) +var logger = Log.repository.getLogger(LOGGER_ID); + +// A map between XML keys to AddonSearchResult keys for string values +// that require no extra parsing from XML +const STRING_KEY_MAP = { + name: "name", + version: "version", + homepage: "homepageURL", + support: "supportURL" +}; + +// A map between XML keys to AddonSearchResult keys for string values +// that require parsing from HTML +const HTML_KEY_MAP = { + summary: "description", + description: "fullDescription", + developer_comments: "developerComments", + eula: "eula" +}; + +// A map between XML keys to AddonSearchResult keys for integer values +// that require no extra parsing from XML +const INTEGER_KEY_MAP = { + total_downloads: "totalDownloads", + weekly_downloads: "weeklyDownloads", + daily_users: "dailyUsers" +}; + +function convertHTMLToPlainText(html) { + if (!html) + return html; + var converter = Cc["@mozilla.org/widget/htmlformatconverter;1"]. + createInstance(Ci.nsIFormatConverter); + + var input = Cc["@mozilla.org/supports-string;1"]. + createInstance(Ci.nsISupportsString); + input.data = html.replace(/\n/g, "
"); + + var output = {}; + converter.convert("text/html", input, input.data.length, "text/unicode", + output, {}); + + if (output.value instanceof Ci.nsISupportsString) + return output.value.data.replace(/\r\n/g, "\n"); + return html; +} + +function getAddonsToCache(aIds, aCallback) { + try { + var types = Services.prefs.getCharPref(PREF_GETADDONS_CACHE_TYPES); + } + catch (e) { } + if (!types) + types = DEFAULT_CACHE_TYPES; + + types = types.split(","); + + AddonManager.getAddonsByIDs(aIds, function(aAddons) { + let enabledIds = []; + for (var i = 0; i < aIds.length; i++) { + var preference = PREF_GETADDONS_CACHE_ID_ENABLED.replace("%ID%", aIds[i]); + try { + if (!Services.prefs.getBoolPref(preference)) + continue; + } catch (e) { + // If the preference doesn't exist caching is enabled by default + } + + // The add-ons manager may not know about this ID yet if it is a pending + // install. In that case we'll just cache it regardless + if (aAddons[i] && (types.indexOf(aAddons[i].type) == -1)) + continue; + + enabledIds.push(aIds[i]); + } + + aCallback(enabledIds); + }); +} + +function AddonSearchResult(aId) { + this.id = aId; + this.icons = {}; + this._unsupportedProperties = {}; +} + +AddonSearchResult.prototype = { + /** + * The ID of the add-on + */ + id: null, + + /** + * The add-on type (e.g. "extension" or "theme") + */ + type: null, + + /** + * The name of the add-on + */ + name: null, + + /** + * The version of the add-on + */ + version: null, + + /** + * The creator of the add-on + */ + creator: null, + + /** + * The developers of the add-on + */ + developers: null, + + /** + * A short description of the add-on + */ + description: null, + + /** + * The full description of the add-on + */ + fullDescription: null, + + /** + * The developer comments for the add-on. This includes any information + * that may be helpful to end users that isn't necessarily applicable to + * the add-on description (e.g. known major bugs) + */ + developerComments: null, + + /** + * The end-user licensing agreement (EULA) of the add-on + */ + eula: null, + + /** + * The url of the add-on's icon + */ + get iconURL() { + return this.icons && this.icons[32]; + }, + + /** + * The URLs of the add-on's icons, as an object with icon size as key + */ + icons: null, + + /** + * An array of screenshot urls for the add-on + */ + screenshots: null, + + /** + * The homepage for the add-on + */ + homepageURL: null, + + /** + * The homepage for the add-on + */ + learnmoreURL: null, + + /** + * The support URL for the add-on + */ + supportURL: null, + + /** + * The contribution url of the add-on + */ + contributionURL: null, + + /** + * The suggested contribution amount + */ + contributionAmount: null, + + /** + * The URL to visit in order to purchase the add-on + */ + purchaseURL: null, + + /** + * The numerical cost of the add-on in some currency, for sorting purposes + * only + */ + purchaseAmount: null, + + /** + * The display cost of the add-on, for display purposes only + */ + purchaseDisplayAmount: null, + + /** + * The rating of the add-on, 0-5 + */ + averageRating: null, + + /** + * The number of reviews for this add-on + */ + reviewCount: null, + + /** + * The URL to the list of reviews for this add-on + */ + reviewURL: null, + + /** + * The total number of times the add-on was downloaded + */ + totalDownloads: null, + + /** + * The number of times the add-on was downloaded the current week + */ + weeklyDownloads: null, + + /** + * The number of daily users for the add-on + */ + dailyUsers: null, + + /** + * AddonInstall object generated from the add-on XPI url + */ + install: null, + + /** + * nsIURI storing where this add-on was installed from + */ + sourceURI: null, + + /** + * The status of the add-on in the repository (e.g. 4 = "Public") + */ + repositoryStatus: null, + + /** + * The size of the add-on's files in bytes. For an add-on that have not yet + * been downloaded this may be an estimated value. + */ + size: null, + + /** + * The Date that the add-on was most recently updated + */ + updateDate: null, + + /** + * True or false depending on whether the add-on is compatible with the + * current version of the application + */ + isCompatible: true, + + /** + * True or false depending on whether the add-on is compatible with the + * current platform + */ + isPlatformCompatible: true, + + /** + * Array of AddonCompatibilityOverride objects, that describe overrides for + * compatibility with an application versions. + **/ + compatibilityOverrides: null, + + /** + * True if the add-on has a secure means of updating + */ + providesUpdatesSecurely: true, + + /** + * The current blocklist state of the add-on + */ + blocklistState: Ci.nsIBlocklistService.STATE_NOT_BLOCKED, + + /** + * True if this add-on cannot be used in the application based on version + * compatibility, dependencies and blocklisting + */ + appDisabled: false, + + /** + * True if the user wants this add-on to be disabled + */ + userDisabled: false, + + /** + * Indicates what scope the add-on is installed in, per profile, user, + * system or application + */ + scope: AddonManager.SCOPE_PROFILE, + + /** + * True if the add-on is currently functional + */ + isActive: true, + + /** + * A bitfield holding all of the current operations that are waiting to be + * performed for this add-on + */ + pendingOperations: AddonManager.PENDING_NONE, + + /** + * A bitfield holding all the the operations that can be performed on + * this add-on + */ + permissions: 0, + + /** + * Tests whether this add-on is known to be compatible with a + * particular application and platform version. + * + * @param appVersion + * An application version to test against + * @param platformVersion + * A platform version to test against + * @return Boolean representing if the add-on is compatible + */ + isCompatibleWith: function(aAppVersion, aPlatformVersion) { + return true; + }, + + /** + * Starts an update check for this add-on. This will perform + * asynchronously and deliver results to the given listener. + * + * @param aListener + * An UpdateListener for the update process + * @param aReason + * A reason code for performing the update + * @param aAppVersion + * An application version to check for updates for + * @param aPlatformVersion + * A platform version to check for updates for + */ + findUpdates: function(aListener, aReason, aAppVersion, aPlatformVersion) { + if ("onNoCompatibilityUpdateAvailable" in aListener) + aListener.onNoCompatibilityUpdateAvailable(this); + if ("onNoUpdateAvailable" in aListener) + aListener.onNoUpdateAvailable(this); + if ("onUpdateFinished" in aListener) + aListener.onUpdateFinished(this); + }, + + toJSON: function() { + let json = {}; + + for (let property of Object.keys(this)) { + let value = this[property]; + if (property.startsWith("_") || + typeof(value) === "function") + continue; + + try { + switch (property) { + case "sourceURI": + json.sourceURI = value ? value.spec : ""; + break; + + case "updateDate": + json.updateDate = value ? value.getTime() : ""; + break; + + default: + json[property] = value; + } + } catch (ex) { + logger.warn("Error writing property value for " + property); + } + } + + for (let property of Object.keys(this._unsupportedProperties)) { + let value = this._unsupportedProperties[property]; + if (!property.startsWith("_")) + json[property] = value; + } + + return json; + } +} + +/** + * The add-on repository is a source of add-ons that can be installed. It can + * be searched in three ways. The first takes a list of IDs and returns a + * list of the corresponding add-ons. The second returns a list of add-ons that + * come highly recommended. This list should change frequently. The third is to + * search for specific search terms entered by the user. Searches are + * asynchronous and results should be passed to the provided callback object + * when complete. The results passed to the callback should only include add-ons + * that are compatible with the current application and are not already + * installed. + */ +this.AddonRepository = { + /** + * Whether caching is currently enabled + */ + get cacheEnabled() { + let preference = PREF_GETADDONS_CACHE_ENABLED; + let enabled = false; + try { + enabled = Services.prefs.getBoolPref(preference); + } catch (e) { + logger.warn("cacheEnabled: Couldn't get pref: " + preference); + } + + return enabled; + }, + + // A cache of the add-ons stored in the database + _addons: null, + + // Whether a search is currently in progress + _searching: false, + + // XHR associated with the current request + _request: null, + + /* + * Addon search results callback object that contains two functions + * + * searchSucceeded - Called when a search has suceeded. + * + * @param aAddons + * An array of the add-on results. In the case of searching for + * specific terms the ordering of results may be determined by + * the search provider. + * @param aAddonCount + * The length of aAddons + * @param aTotalResults + * The total results actually available in the repository + * + * + * searchFailed - Called when an error occurred when performing a search. + */ + _callback: null, + + // Maximum number of results to return + _maxResults: null, + + /** + * Shut down AddonRepository + * return: promise{integer} resolves with the result of flushing + * the AddonRepository database + */ + shutdown: function() { + this.cancelSearch(); + + this._addons = null; + return AddonDatabase.shutdown(false); + }, + + metadataAge: function() { + let now = Math.round(Date.now() / 1000); + + let lastUpdate = 0; + try { + lastUpdate = Services.prefs.getIntPref(PREF_METADATA_LASTUPDATE); + } catch (e) {} + + // Handle clock jumps + if (now < lastUpdate) { + return now; + } + return now - lastUpdate; + }, + + isMetadataStale: function() { + let threshold = DEFAULT_METADATA_UPDATETHRESHOLD_SEC; + try { + threshold = Services.prefs.getIntPref(PREF_METADATA_UPDATETHRESHOLD_SEC); + } catch (e) {} + return (this.metadataAge() > threshold); + }, + + /** + * Asynchronously get a cached add-on by id. The add-on (or null if the + * add-on is not found) is passed to the specified callback. If caching is + * disabled, null is passed to the specified callback. + * + * @param aId + * The id of the add-on to get + * @param aCallback + * The callback to pass the result back to + */ + getCachedAddonByID: Task.async(function*(aId, aCallback) { + if (!aId || !this.cacheEnabled) { + aCallback(null); + return; + } + + function getAddon(aAddons) { + aCallback(aAddons.get(aId) || null); + } + + if (this._addons == null) { + AddonDatabase.retrieveStoredData().then(aAddons => { + this._addons = aAddons; + getAddon(aAddons); + }); + + return; + } + + getAddon(this._addons); + }), + + /** + * Asynchronously repopulate cache so it only contains the add-ons + * corresponding to the specified ids. If caching is disabled, + * the cache is completely removed. + * + * @param aTimeout + * (Optional) timeout in milliseconds to abandon the XHR request + * if we have not received a response from the server. + * @return Promise{null} + * Resolves when the metadata ping is complete + */ + repopulateCache: function(aTimeout) { + return this._repopulateCacheInternal(false, aTimeout); + }, + + /* + * Clear and delete the AddonRepository database + * @return Promise{null} resolves when the database is deleted + */ + _clearCache: function() { + this._addons = null; + return AddonDatabase.delete().then(() => + new Promise((resolve, reject) => + AddonManagerPrivate.updateAddonRepositoryData(resolve)) + ); + }, + + _repopulateCacheInternal: Task.async(function*(aSendPerformance, aTimeout) { + let allAddons = yield new Promise((resolve, reject) => + AddonManager.getAllAddons(resolve)); + + // Filter the hotfix out of our list of add-ons + allAddons = allAddons.filter(a => a.id != AddonManager.hotfixID); + + // Completely remove cache if caching is not enabled + if (!this.cacheEnabled) { + logger.debug("Clearing cache because it is disabled"); + yield this._clearCache(); + return; + } + + let ids = allAddons.map(a => a.id); + logger.debug("Repopulate add-on cache with " + ids.toSource()); + + let addonsToCache = yield new Promise((resolve, reject) => + getAddonsToCache(ids, resolve)); + + // Completely remove cache if there are no add-ons to cache + if (addonsToCache.length == 0) { + logger.debug("Clearing cache because 0 add-ons were requested"); + yield this._clearCache(); + return; + } + + yield new Promise((resolve, reject) => + this._beginGetAddons(addonsToCache, { + searchSucceeded: aAddons => { + this._addons = new Map(); + for (let addon of aAddons) { + this._addons.set(addon.id, addon); + } + AddonDatabase.repopulate(aAddons, resolve); + }, + searchFailed: () => { + logger.warn("Search failed when repopulating cache"); + resolve(); + } + }, aSendPerformance, aTimeout)); + + // Always call AddonManager updateAddonRepositoryData after we refill the cache + yield new Promise((resolve, reject) => + AddonManagerPrivate.updateAddonRepositoryData(resolve)); + }), + + /** + * Asynchronously add add-ons to the cache corresponding to the specified + * ids. If caching is disabled, the cache is unchanged and the callback is + * immediately called if it is defined. + * + * @param aIds + * The array of add-on ids to add to the cache + * @param aCallback + * The optional callback to call once complete + */ + cacheAddons: function(aIds, aCallback) { + logger.debug("cacheAddons: enabled " + this.cacheEnabled + " IDs " + aIds.toSource()); + if (!this.cacheEnabled) { + if (aCallback) + aCallback(); + return; + } + + getAddonsToCache(aIds, aAddons => { + // If there are no add-ons to cache, act as if caching is disabled + if (aAddons.length == 0) { + if (aCallback) + aCallback(); + return; + } + + this.getAddonsByIDs(aAddons, { + searchSucceeded: aAddons => { + for (let addon of aAddons) { + this._addons.set(addon.id, addon); + } + AddonDatabase.insertAddons(aAddons, aCallback); + }, + searchFailed: () => { + logger.warn("Search failed when adding add-ons to cache"); + if (aCallback) + aCallback(); + } + }); + }); + }, + + /** + * The homepage for visiting this repository. If the corresponding preference + * is not defined, defaults to about:blank. + */ + get homepageURL() { + let url = this._formatURLPref(PREF_GETADDONS_BROWSEADDONS, {}); + return (url != null) ? url : "about:blank"; + }, + + /** + * Returns whether this instance is currently performing a search. New + * searches will not be performed while this is the case. + */ + get isSearching() { + return this._searching; + }, + + /** + * The url that can be visited to see recommended add-ons in this repository. + * If the corresponding preference is not defined, defaults to about:blank. + */ + getRecommendedURL: function() { + let url = this._formatURLPref(PREF_GETADDONS_BROWSERECOMMENDED, {}); + return (url != null) ? url : "about:blank"; + }, + + /** + * Retrieves the url that can be visited to see search results for the given + * terms. If the corresponding preference is not defined, defaults to + * about:blank. + * + * @param aSearchTerms + * Search terms used to search the repository + */ + getSearchURL: function(aSearchTerms) { + let url = this._formatURLPref(PREF_GETADDONS_BROWSESEARCHRESULTS, { + TERMS : encodeURIComponent(aSearchTerms) + }); + return (url != null) ? url : "about:blank"; + }, + + /** + * Cancels the search in progress. If there is no search in progress this + * does nothing. + */ + cancelSearch: function() { + this._searching = false; + if (this._request) { + this._request.abort(); + this._request = null; + } + this._callback = null; + }, + + /** + * Begins a search for add-ons in this repository by ID. Results will be + * passed to the given callback. + * + * @param aIDs + * The array of ids to search for + * @param aCallback + * The callback to pass results to + */ + getAddonsByIDs: function(aIDs, aCallback) { + return this._beginGetAddons(aIDs, aCallback, false); + }, + + /** + * Begins a search of add-ons, potentially sending performance data. + * + * @param aIDs + * Array of ids to search for. + * @param aCallback + * Function to pass results to. + * @param aSendPerformance + * Boolean indicating whether to send performance data with the + * request. + * @param aTimeout + * (Optional) timeout in milliseconds to abandon the XHR request + * if we have not received a response from the server. + */ + _beginGetAddons: function(aIDs, aCallback, aSendPerformance, aTimeout) { + let ids = aIDs.slice(0); + + let params = { + API_VERSION : API_VERSION, + IDS : ids.map(encodeURIComponent).join(',') + }; + + let pref = PREF_GETADDONS_BYIDS; + + if (aSendPerformance) { + let type = Services.prefs.getPrefType(PREF_GETADDONS_BYIDS_PERFORMANCE); + if (type == Services.prefs.PREF_STRING) { + pref = PREF_GETADDONS_BYIDS_PERFORMANCE; + + let startupInfo = Cc["@mozilla.org/toolkit/app-startup;1"]. + getService(Ci.nsIAppStartup). + getStartupInfo(); + + params.TIME_MAIN = ""; + params.TIME_FIRST_PAINT = ""; + params.TIME_SESSION_RESTORED = ""; + if (startupInfo.process) { + if (startupInfo.main) { + params.TIME_MAIN = startupInfo.main - startupInfo.process; + } + if (startupInfo.firstPaint) { + params.TIME_FIRST_PAINT = startupInfo.firstPaint - + startupInfo.process; + } + if (startupInfo.sessionRestored) { + params.TIME_SESSION_RESTORED = startupInfo.sessionRestored - + startupInfo.process; + } + } + } + } + + let url = this._formatURLPref(pref, params); + + let handleResults = (aElements, aTotalResults, aCompatData) => { + // Don't use this._parseAddons() so that, for example, + // incompatible add-ons are not filtered out + let results = []; + for (let i = 0; i < aElements.length && results.length < this._maxResults; i++) { + let result = this._parseAddon(aElements[i], null, aCompatData); + if (result == null) + continue; + + // Ignore add-on if it wasn't actually requested + let idIndex = ids.indexOf(result.addon.id); + if (idIndex == -1) + continue; + + // Ignore add-on if the add-on manager doesn't know about its type: + if (!(result.addon.type in AddonManager.addonTypes)) { + continue; + } + + results.push(result); + // Ignore this add-on from now on + ids.splice(idIndex, 1); + } + + // Include any compatibility overrides for addons not hosted by the + // remote repository. + for (let id in aCompatData) { + let addonCompat = aCompatData[id]; + if (addonCompat.hosted) + continue; + + let addon = new AddonSearchResult(addonCompat.id); + // Compatibility overrides can only be for extensions. + addon.type = "extension"; + addon.compatibilityOverrides = addonCompat.compatRanges; + let result = { + addon: addon, + xpiURL: null, + xpiHash: null + }; + results.push(result); + } + + // aTotalResults irrelevant + this._reportSuccess(results, -1); + } + + this._beginSearch(url, ids.length, aCallback, handleResults, aTimeout); + }, + + /** + * Performs the daily background update check. + * + * This API both searches for the add-on IDs specified and sends performance + * data. It is meant to be called as part of the daily update ping. It should + * not be used for any other purpose. Use repopulateCache instead. + * + * @return Promise{null} Resolves when the metadata update is complete. + */ + backgroundUpdateCheck: function() { + return this._repopulateCacheInternal(true); + }, + + /** + * Begins a search for recommended add-ons in this repository. Results will + * be passed to the given callback. + * + * @param aMaxResults + * The maximum number of results to return + * @param aCallback + * The callback to pass results to + */ + retrieveRecommendedAddons: function(aMaxResults, aCallback) { + let url = this._formatURLPref(PREF_GETADDONS_GETRECOMMENDED, { + API_VERSION : API_VERSION, + + // Get twice as many results to account for potential filtering + MAX_RESULTS : 2 * aMaxResults + }); + + let handleResults = (aElements, aTotalResults) => { + this._getLocalAddonIds(aLocalAddonIds => { + // aTotalResults irrelevant + this._parseAddons(aElements, -1, aLocalAddonIds); + }); + } + + this._beginSearch(url, aMaxResults, aCallback, handleResults); + }, + + /** + * Begins a search for add-ons in this repository. Results will be passed to + * the given callback. + * + * @param aSearchTerms + * The terms to search for + * @param aMaxResults + * The maximum number of results to return + * @param aCallback + * The callback to pass results to + */ + searchAddons: function(aSearchTerms, aMaxResults, aCallback) { + let compatMode = "normal"; + if (!AddonManager.checkCompatibility) + compatMode = "ignore"; + else if (AddonManager.strictCompatibility) + compatMode = "strict"; + + let substitutions = { + API_VERSION : API_VERSION, + TERMS : encodeURIComponent(aSearchTerms), + // Get twice as many results to account for potential filtering + MAX_RESULTS : 2 * aMaxResults, + COMPATIBILITY_MODE : compatMode, + }; + + let url = this._formatURLPref(PREF_GETADDONS_GETSEARCHRESULTS, substitutions); + + let handleResults = (aElements, aTotalResults) => { + this._getLocalAddonIds(aLocalAddonIds => { + this._parseAddons(aElements, aTotalResults, aLocalAddonIds); + }); + } + + this._beginSearch(url, aMaxResults, aCallback, handleResults); + }, + + // Posts results to the callback + _reportSuccess: function(aResults, aTotalResults) { + this._searching = false; + this._request = null; + // The callback may want to trigger a new search so clear references early + let addons = aResults.map(result => result.addon); + let callback = this._callback; + this._callback = null; + callback.searchSucceeded(addons, addons.length, aTotalResults); + }, + + // Notifies the callback of a failure + _reportFailure: function() { + this._searching = false; + this._request = null; + // The callback may want to trigger a new search so clear references early + let callback = this._callback; + this._callback = null; + callback.searchFailed(); + }, + + // Get descendant by unique tag name. Returns null if not unique tag name. + _getUniqueDescendant: function(aElement, aTagName) { + let elementsList = aElement.getElementsByTagName(aTagName); + return (elementsList.length == 1) ? elementsList[0] : null; + }, + + // Get direct descendant by unique tag name. + // Returns null if not unique tag name. + _getUniqueDirectDescendant: function(aElement, aTagName) { + let elementsList = Array.filter(aElement.children, + aChild => aChild.tagName == aTagName); + return (elementsList.length == 1) ? elementsList[0] : null; + }, + + // Parse out trimmed text content. Returns null if text content empty. + _getTextContent: function(aElement) { + let textContent = aElement.textContent.trim(); + return (textContent.length > 0) ? textContent : null; + }, + + // Parse out trimmed text content of a descendant with the specified tag name + // Returns null if the parsing unsuccessful. + _getDescendantTextContent: function(aElement, aTagName) { + let descendant = this._getUniqueDescendant(aElement, aTagName); + return (descendant != null) ? this._getTextContent(descendant) : null; + }, + + // Parse out trimmed text content of a direct descendant with the specified + // tag name. + // Returns null if the parsing unsuccessful. + _getDirectDescendantTextContent: function(aElement, aTagName) { + let descendant = this._getUniqueDirectDescendant(aElement, aTagName); + return (descendant != null) ? this._getTextContent(descendant) : null; + }, + + /* + * Creates an AddonSearchResult by parsing an element + * + * @param aElement + * The element to parse + * @param aSkip + * Object containing ids and sourceURIs of add-ons to skip. + * @param aCompatData + * Array of parsed addon_compatibility elements to accosiate with the + * resulting AddonSearchResult. Optional. + * @return Result object containing the parsed AddonSearchResult, xpiURL and + * xpiHash if the parsing was successful. Otherwise returns null. + */ + _parseAddon: function(aElement, aSkip, aCompatData) { + let skipIDs = (aSkip && aSkip.ids) ? aSkip.ids : []; + let skipSourceURIs = (aSkip && aSkip.sourceURIs) ? aSkip.sourceURIs : []; + + let guid = this._getDescendantTextContent(aElement, "guid"); + if (guid == null || skipIDs.indexOf(guid) != -1) + return null; + + let addon = new AddonSearchResult(guid); + let result = { + addon: addon, + xpiURL: null, + xpiHash: null + }; + + if (aCompatData && guid in aCompatData) + addon.compatibilityOverrides = aCompatData[guid].compatRanges; + + for (let node = aElement.firstChild; node; node = node.nextSibling) { + if (!(node instanceof Ci.nsIDOMElement)) + continue; + + let localName = node.localName; + + // Handle case where the wanted string value is located in text content + // but only if the content is not empty + if (localName in STRING_KEY_MAP) { + addon[STRING_KEY_MAP[localName]] = this._getTextContent(node) || addon[STRING_KEY_MAP[localName]]; + continue; + } + + // Handle case where the wanted string value is html located in text content + if (localName in HTML_KEY_MAP) { + addon[HTML_KEY_MAP[localName]] = convertHTMLToPlainText(this._getTextContent(node)); + continue; + } + + // Handle case where the wanted integer value is located in text content + if (localName in INTEGER_KEY_MAP) { + let value = parseInt(this._getTextContent(node)); + if (value >= 0) + addon[INTEGER_KEY_MAP[localName]] = value; + continue; + } + + // Handle cases that aren't as simple as grabbing the text content + switch (localName) { + case "type": + // Map AMO's type id to corresponding string + // https://github.com/mozilla/olympia/blob/master/apps/constants/base.py#L127 + // These definitions need to be updated whenever AMO adds a new type. + let id = parseInt(node.getAttribute("id")); + switch (id) { + case 1: + addon.type = "extension"; + break; + case 2: + addon.type = "theme"; + break; + case 3: + addon.type = "dictionary"; + break; + case 4: + addon.type = "search"; + break; + case 5: + case 6: + addon.type = "locale"; + break; + case 7: + addon.type = "plugin"; + break; + case 8: + addon.type = "api"; + break; + case 9: + addon.type = "lightweight-theme"; + break; + case 11: + addon.type = "webapp"; + break; + default: + logger.info("Unknown type id " + id + " found when parsing response for GUID " + guid); + } + break; + case "authors": + let authorNodes = node.getElementsByTagName("author"); + for (let authorNode of authorNodes) { + let name = this._getDescendantTextContent(authorNode, "name"); + let link = this._getDescendantTextContent(authorNode, "link"); + if (name == null || link == null) + continue; + + let author = new AddonManagerPrivate.AddonAuthor(name, link); + if (addon.creator == null) + addon.creator = author; + else { + if (addon.developers == null) + addon.developers = []; + + addon.developers.push(author); + } + } + break; + case "previews": + let previewNodes = node.getElementsByTagName("preview"); + for (let previewNode of previewNodes) { + let full = this._getUniqueDescendant(previewNode, "full"); + if (full == null) + continue; + + let fullURL = this._getTextContent(full); + let fullWidth = full.getAttribute("width"); + let fullHeight = full.getAttribute("height"); + + let thumbnailURL, thumbnailWidth, thumbnailHeight; + let thumbnail = this._getUniqueDescendant(previewNode, "thumbnail"); + if (thumbnail) { + thumbnailURL = this._getTextContent(thumbnail); + thumbnailWidth = thumbnail.getAttribute("width"); + thumbnailHeight = thumbnail.getAttribute("height"); + } + let caption = this._getDescendantTextContent(previewNode, "caption"); + let screenshot = new AddonManagerPrivate.AddonScreenshot(fullURL, fullWidth, fullHeight, + thumbnailURL, thumbnailWidth, + thumbnailHeight, caption); + + if (addon.screenshots == null) + addon.screenshots = []; + + if (previewNode.getAttribute("primary") == 1) + addon.screenshots.unshift(screenshot); + else + addon.screenshots.push(screenshot); + } + break; + case "learnmore": + addon.learnmoreURL = this._getTextContent(node); + addon.homepageURL = addon.homepageURL || addon.learnmoreURL; + break; + case "contribution_data": + let meetDevelopers = this._getDescendantTextContent(node, "meet_developers"); + let suggestedAmount = this._getDescendantTextContent(node, "suggested_amount"); + if (meetDevelopers != null) { + addon.contributionURL = meetDevelopers; + addon.contributionAmount = suggestedAmount; + } + break + case "payment_data": + let link = this._getDescendantTextContent(node, "link"); + let amountTag = this._getUniqueDescendant(node, "amount"); + let amount = parseFloat(amountTag.getAttribute("amount")); + let displayAmount = this._getTextContent(amountTag); + if (link != null && amount != null && displayAmount != null) { + addon.purchaseURL = link; + addon.purchaseAmount = amount; + addon.purchaseDisplayAmount = displayAmount; + } + break + case "rating": + let averageRating = parseInt(this._getTextContent(node)); + if (averageRating >= 0) + addon.averageRating = Math.min(5, averageRating); + break; + case "reviews": + let url = this._getTextContent(node); + let num = parseInt(node.getAttribute("num")); + if (url != null && num >= 0) { + addon.reviewURL = url; + addon.reviewCount = num; + } + break; + case "status": + let repositoryStatus = parseInt(node.getAttribute("id")); + if (!isNaN(repositoryStatus)) + addon.repositoryStatus = repositoryStatus; + break; + case "all_compatible_os": + let nodes = node.getElementsByTagName("os"); + addon.isPlatformCompatible = Array.some(nodes, function(aNode) { + let text = aNode.textContent.toLowerCase().trim(); + return text == "all" || text == Services.appinfo.OS.toLowerCase(); + }); + break; + case "install": + // No os attribute means the xpi is compatible with any os + if (node.hasAttribute("os")) { + let os = node.getAttribute("os").trim().toLowerCase(); + // If the os is not ALL and not the current OS then ignore this xpi + if (os != "all" && os != Services.appinfo.OS.toLowerCase()) + break; + } + + let xpiURL = this._getTextContent(node); + if (xpiURL == null) + break; + + if (skipSourceURIs.indexOf(xpiURL) != -1) + return null; + + result.xpiURL = xpiURL; + addon.sourceURI = NetUtil.newURI(xpiURL); + + let size = parseInt(node.getAttribute("size")); + addon.size = (size >= 0) ? size : null; + + let xpiHash = node.getAttribute("hash"); + if (xpiHash != null) + xpiHash = xpiHash.trim(); + result.xpiHash = xpiHash ? xpiHash : null; + break; + case "last_updated": + let epoch = parseInt(node.getAttribute("epoch")); + if (!isNaN(epoch)) + addon.updateDate = new Date(1000 * epoch); + break; + case "icon": + addon.icons[node.getAttribute("size")] = this._getTextContent(node); + break; + } + } + + return result; + }, + + _parseAddons: function(aElements, aTotalResults, aSkip) { + let results = []; + + let isSameApplication = aAppNode => this._getTextContent(aAppNode) == Services.appinfo.ID; + + for (let i = 0; i < aElements.length && results.length < this._maxResults; i++) { + let element = aElements[i]; + + let tags = this._getUniqueDescendant(element, "compatible_applications"); + if (tags == null) + continue; + + let applications = tags.getElementsByTagName("appID"); + let compatible = Array.some(applications, aAppNode => { + if (!isSameApplication(aAppNode)) + return false; + + let parent = aAppNode.parentNode; + let minVersion = this._getDescendantTextContent(parent, "min_version"); + let maxVersion = this._getDescendantTextContent(parent, "max_version"); + if (minVersion == null || maxVersion == null) + return false; + + let currentVersion = Services.appinfo.version; + return (Services.vc.compare(minVersion, currentVersion) <= 0 && + ((!AddonManager.strictCompatibility) || + Services.vc.compare(currentVersion, maxVersion) <= 0)); + }); + + // Ignore add-ons not compatible with this Application + if (!compatible) { + if (AddonManager.checkCompatibility) + continue; + + if (!Array.some(applications, isSameApplication)) + continue; + } + + // Add-on meets all requirements, so parse out data. + // Don't pass in compatiblity override data, because that's only returned + // in GUID searches, which don't use _parseAddons(). + let result = this._parseAddon(element, aSkip); + if (result == null) + continue; + + // Ignore add-on missing a required attribute + let requiredAttributes = ["id", "name", "version", "type", "creator"]; + if (requiredAttributes.some(aAttribute => !result.addon[aAttribute])) + continue; + + // Ignore add-on with a type AddonManager doesn't understand: + if (!(result.addon.type in AddonManager.addonTypes)) + continue; + + // Add only if the add-on is compatible with the platform + if (!result.addon.isPlatformCompatible) + continue; + + // Add only if there was an xpi compatible with this OS or there was a + // way to purchase the add-on + if (!result.xpiURL && !result.addon.purchaseURL) + continue; + + result.addon.isCompatible = compatible; + + results.push(result); + // Ignore this add-on from now on by adding it to the skip array + aSkip.ids.push(result.addon.id); + } + + // Immediately report success if no AddonInstall instances to create + let pendingResults = results.length; + if (pendingResults == 0) { + this._reportSuccess(results, aTotalResults); + return; + } + + // Create an AddonInstall for each result + for (let result of results) { + let addon = result.addon; + let callback = aInstall => { + addon.install = aInstall; + pendingResults--; + if (pendingResults == 0) + this._reportSuccess(results, aTotalResults); + } + + if (result.xpiURL) { + AddonManager.getInstallForURL(result.xpiURL, callback, + "application/x-xpinstall", result.xpiHash, + addon.name, addon.icons, addon.version); + } + else { + callback(null); + } + } + }, + + // Parses addon_compatibility nodes, that describe compatibility overrides. + _parseAddonCompatElement: function(aResultObj, aElement) { + let guid = this._getDescendantTextContent(aElement, "guid"); + if (!guid) { + logger.debug("Compatibility override is missing guid."); + return; + } + + let compat = {id: guid}; + compat.hosted = aElement.getAttribute("hosted") != "false"; + + function findMatchingAppRange(aNodes) { + let toolkitAppRange = null; + for (let node of aNodes) { + let appID = this._getDescendantTextContent(node, "appID"); + if (appID != Services.appinfo.ID && appID != TOOLKIT_ID) + continue; + + let minVersion = this._getDescendantTextContent(node, "min_version"); + let maxVersion = this._getDescendantTextContent(node, "max_version"); + if (minVersion == null || maxVersion == null) + continue; + + let appRange = { appID: appID, + appMinVersion: minVersion, + appMaxVersion: maxVersion }; + + // Only use Toolkit app ranges if no ranges match the application ID. + if (appID == TOOLKIT_ID) + toolkitAppRange = appRange; + else + return appRange; + } + return toolkitAppRange; + } + + function parseRangeNode(aNode) { + let type = aNode.getAttribute("type"); + // Only "incompatible" (blacklisting) is supported for now. + if (type != "incompatible") { + logger.debug("Compatibility override of unsupported type found."); + return null; + } + + let override = new AddonManagerPrivate.AddonCompatibilityOverride(type); + + override.minVersion = this._getDirectDescendantTextContent(aNode, "min_version"); + override.maxVersion = this._getDirectDescendantTextContent(aNode, "max_version"); + + if (!override.minVersion) { + logger.debug("Compatibility override is missing min_version."); + return null; + } + if (!override.maxVersion) { + logger.debug("Compatibility override is missing max_version."); + return null; + } + + let appRanges = aNode.querySelectorAll("compatible_applications > application"); + let appRange = findMatchingAppRange.bind(this)(appRanges); + if (!appRange) { + logger.debug("Compatibility override is missing a valid application range."); + return null; + } + + override.appID = appRange.appID; + override.appMinVersion = appRange.appMinVersion; + override.appMaxVersion = appRange.appMaxVersion; + + return override; + } + + let rangeNodes = aElement.querySelectorAll("version_ranges > version_range"); + compat.compatRanges = Array.map(rangeNodes, parseRangeNode.bind(this)) + .filter(aItem => !!aItem); + if (compat.compatRanges.length == 0) + return; + + aResultObj[compat.id] = compat; + }, + + // Parses addon_compatibility elements. + _parseAddonCompatData: function(aElements) { + let compatData = {}; + Array.forEach(aElements, this._parseAddonCompatElement.bind(this, compatData)); + return compatData; + }, + + // Begins a new search if one isn't currently executing + _beginSearch: function(aURI, aMaxResults, aCallback, aHandleResults, aTimeout) { + if (this._searching || aURI == null || aMaxResults <= 0) { + logger.warn("AddonRepository search failed: searching " + this._searching + " aURI " + aURI + + " aMaxResults " + aMaxResults); + aCallback.searchFailed(); + return; + } + + this._searching = true; + this._callback = aCallback; + this._maxResults = aMaxResults; + + logger.debug("Requesting " + aURI); + + this._request = new ServiceRequest(); + this._request.mozBackgroundRequest = true; + this._request.open("GET", aURI, true); + this._request.overrideMimeType("text/xml"); + if (aTimeout) { + this._request.timeout = aTimeout; + } + + this._request.addEventListener("error", aEvent => this._reportFailure(), false); + this._request.addEventListener("timeout", aEvent => this._reportFailure(), false); + this._request.addEventListener("load", aEvent => { + logger.debug("Got metadata search load event"); + let request = aEvent.target; + let responseXML = request.responseXML; + + if (!responseXML || responseXML.documentElement.namespaceURI == XMLURI_PARSE_ERROR || + (request.status != 200 && request.status != 0)) { + this._reportFailure(); + return; + } + + let documentElement = responseXML.documentElement; + let elements = documentElement.getElementsByTagName("addon"); + let totalResults = elements.length; + let parsedTotalResults = parseInt(documentElement.getAttribute("total_results")); + // Parsed value of total results only makes sense if >= elements.length + if (parsedTotalResults >= totalResults) + totalResults = parsedTotalResults; + + let compatElements = documentElement.getElementsByTagName("addon_compatibility"); + let compatData = this._parseAddonCompatData(compatElements); + + aHandleResults(elements, totalResults, compatData); + }, false); + this._request.send(null); + }, + + // Gets the id's of local add-ons, and the sourceURI's of local installs, + // passing the results to aCallback + _getLocalAddonIds: function(aCallback) { + let localAddonIds = {ids: null, sourceURIs: null}; + + AddonManager.getAllAddons(function(aAddons) { + localAddonIds.ids = aAddons.map(a => a.id); + if (localAddonIds.sourceURIs) + aCallback(localAddonIds); + }); + + AddonManager.getAllInstalls(function(aInstalls) { + localAddonIds.sourceURIs = []; + for (let install of aInstalls) { + if (install.state != AddonManager.STATE_AVAILABLE) + localAddonIds.sourceURIs.push(install.sourceURI.spec); + } + + if (localAddonIds.ids) + aCallback(localAddonIds); + }); + }, + + // Create url from preference, returning null if preference does not exist + _formatURLPref: function(aPreference, aSubstitutions) { + let url = null; + try { + url = Services.prefs.getCharPref(aPreference); + } catch (e) { + logger.warn("_formatURLPref: Couldn't get pref: " + aPreference); + return null; + } + + url = url.replace(/%([A-Z_]+)%/g, function(aMatch, aKey) { + return (aKey in aSubstitutions) ? aSubstitutions[aKey] : aMatch; + }); + + return Services.urlFormatter.formatURL(url); + }, + + // Find a AddonCompatibilityOverride that matches a given aAddonVersion and + // application/platform version. + findMatchingCompatOverride: function(aAddonVersion, + aCompatOverrides, + aAppVersion, + aPlatformVersion) { + for (let override of aCompatOverrides) { + + let appVersion = null; + if (override.appID == TOOLKIT_ID) + appVersion = aPlatformVersion || Services.appinfo.platformVersion; + else + appVersion = aAppVersion || Services.appinfo.version; + + if (Services.vc.compare(override.minVersion, aAddonVersion) <= 0 && + Services.vc.compare(aAddonVersion, override.maxVersion) <= 0 && + Services.vc.compare(override.appMinVersion, appVersion) <= 0 && + Services.vc.compare(appVersion, override.appMaxVersion) <= 0) { + return override; + } + } + return null; + }, + + flush: function() { + return AddonDatabase.flush(); + } +}; + +var AddonDatabase = { + connectionPromise: null, + // the in-memory database + DB: BLANK_DB(), + + /** + * A getter to retrieve the path to the DB + */ + get jsonFile() { + return OS.Path.join(OS.Constants.Path.profileDir, FILE_DATABASE); + }, + + /** + * Asynchronously opens a new connection to the database file. + * + * @return {Promise} a promise that resolves to the database. + */ + openConnection: function() { + if (!this.connectionPromise) { + this.connectionPromise = Task.spawn(function*() { + this.DB = BLANK_DB(); + + let inputDB, schema; + + try { + let data = yield OS.File.read(this.jsonFile, { encoding: "utf-8"}) + inputDB = JSON.parse(data); + + if (!inputDB.hasOwnProperty("addons") || + !Array.isArray(inputDB.addons)) { + throw new Error("No addons array."); + } + + if (!inputDB.hasOwnProperty("schema")) { + throw new Error("No schema specified."); + } + + schema = parseInt(inputDB.schema, 10); + + if (!Number.isInteger(schema) || + schema < DB_MIN_JSON_SCHEMA) { + throw new Error("Invalid schema value."); + } + } catch (e) { + if (e instanceof OS.File.Error && e.becauseNoSuchFile) { + logger.debug("No " + FILE_DATABASE + " found."); + } else { + logger.error(`Malformed ${FILE_DATABASE}: ${e} - resetting to empty`); + } + + // Create a blank addons.json file + this._saveDBToDisk(); + + let dbSchema = 0; + try { + dbSchema = Services.prefs.getIntPref(PREF_GETADDONS_DB_SCHEMA); + } catch (e) {} + + if (dbSchema < DB_MIN_JSON_SCHEMA) { + let results = yield new Promise((resolve, reject) => { + AddonRepository_SQLiteMigrator.migrate(resolve); + }); + + if (results.length) { + yield this._insertAddons(results); + } + + } + + Services.prefs.setIntPref(PREF_GETADDONS_DB_SCHEMA, DB_SCHEMA); + return this.DB; + } + + Services.prefs.setIntPref(PREF_GETADDONS_DB_SCHEMA, DB_SCHEMA); + + // We use _insertAddon manually instead of calling + // insertAddons to avoid the write to disk which would + // be a waste since this is the data that was just read. + for (let addon of inputDB.addons) { + this._insertAddon(addon); + } + + return this.DB; + }.bind(this)); + } + + return this.connectionPromise; + }, + + /** + * A lazy getter for the database connection. + */ + get connection() { + return this.openConnection(); + }, + + /** + * Asynchronously shuts down the database connection and releases all + * cached objects + * + * @param aCallback + * An optional callback to call once complete + * @param aSkipFlush + * An optional boolean to skip flushing data to disk. Useful + * when the database is going to be deleted afterwards. + */ + shutdown: function(aSkipFlush) { + if (!this.connectionPromise) { + return Promise.resolve(); + } + + this.connectionPromise = null; + + if (aSkipFlush) { + return Promise.resolve(); + } + return this.Writer.flush(); + }, + + /** + * Asynchronously deletes the database, shutting down the connection + * first if initialized + * + * @param aCallback + * An optional callback to call once complete + * @return Promise{null} resolves when the database has been deleted + */ + delete: function(aCallback) { + this.DB = BLANK_DB(); + + this._deleting = this.Writer.flush() + .then(null, () => {}) + // shutdown(true) never rejects + .then(() => this.shutdown(true)) + .then(() => OS.File.remove(this.jsonFile, {})) + .then(null, error => logger.error("Unable to delete Addon Repository file " + + this.jsonFile, error)) + .then(() => this._deleting = null) + .then(aCallback); + return this._deleting; + }, + + toJSON: function() { + let json = { + schema: this.DB.schema, + addons: [] + } + + for (let [, value] of this.DB.addons) + json.addons.push(value); + + return json; + }, + + /* + * This is a deferred task writer that is used + * to batch operations done within 50ms of each + * other and thus generating only one write to disk + */ + get Writer() { + delete this.Writer; + this.Writer = new DeferredSave( + this.jsonFile, + () => { return JSON.stringify(this); }, + DB_BATCH_TIMEOUT_MS + ); + return this.Writer; + }, + + /** + * Flush any pending I/O on the addons.json file + * @return: Promise{null} + * Resolves when the pending I/O (writing out or deleting + * addons.json) completes + */ + flush: function() { + if (this._deleting) { + return this._deleting; + } + return this.Writer.flush(); + }, + + /** + * Asynchronously retrieve all add-ons from the database + * @return: Promise{Map} + * Resolves when the add-ons are retrieved from the database + */ + retrieveStoredData: function() { + return this.openConnection().then(db => db.addons); + }, + + /** + * Asynchronously repopulates the database so it only contains the + * specified add-ons + * + * @param aAddons + * The array of add-ons to repopulate the database with + * @param aCallback + * An optional callback to call once complete + */ + repopulate: function(aAddons, aCallback) { + this.DB.addons.clear(); + this.insertAddons(aAddons, function() { + let now = Math.round(Date.now() / 1000); + logger.debug("Cache repopulated, setting " + PREF_METADATA_LASTUPDATE + " to " + now); + Services.prefs.setIntPref(PREF_METADATA_LASTUPDATE, now); + if (aCallback) + aCallback(); + }); + }, + + /** + * Asynchronously inserts an array of add-ons into the database + * + * @param aAddons + * The array of add-ons to insert + * @param aCallback + * An optional callback to call once complete + */ + insertAddons: Task.async(function*(aAddons, aCallback) { + yield this.openConnection(); + yield this._insertAddons(aAddons, aCallback); + }), + + _insertAddons: Task.async(function*(aAddons, aCallback) { + for (let addon of aAddons) { + this._insertAddon(addon); + } + + yield this._saveDBToDisk(); + aCallback && aCallback(); + }), + + /** + * Inserts an individual add-on into the database. If the add-on already + * exists in the database (by id), then the specified add-on will not be + * inserted. + * + * @param aAddon + * The add-on to insert into the database + * @param aCallback + * The callback to call once complete + */ + _insertAddon: function(aAddon) { + let newAddon = this._parseAddon(aAddon); + if (!newAddon || + !newAddon.id || + this.DB.addons.has(newAddon.id)) + return; + + this.DB.addons.set(newAddon.id, newAddon); + }, + + /* + * Creates an AddonSearchResult by parsing an object structure + * retrieved from the DB JSON representation. + * + * @param aObj + * The object to parse + * @return Returns an AddonSearchResult object. + */ + _parseAddon: function(aObj) { + if (aObj instanceof AddonSearchResult) + return aObj; + + let id = aObj.id; + if (!aObj.id) + return null; + + let addon = new AddonSearchResult(id); + + for (let expectedProperty of Object.keys(AddonSearchResult.prototype)) { + if (!(expectedProperty in aObj) || + typeof(aObj[expectedProperty]) === "function") + continue; + + let value = aObj[expectedProperty]; + + try { + switch (expectedProperty) { + case "sourceURI": + addon.sourceURI = value ? NetUtil.newURI(value) : null; + break; + + case "creator": + addon.creator = value + ? this._makeDeveloper(value) + : null; + break; + + case "updateDate": + addon.updateDate = value ? new Date(value) : null; + break; + + case "developers": + if (!addon.developers) addon.developers = []; + for (let developer of value) { + addon.developers.push(this._makeDeveloper(developer)); + } + break; + + case "screenshots": + if (!addon.screenshots) addon.screenshots = []; + for (let screenshot of value) { + addon.screenshots.push(this._makeScreenshot(screenshot)); + } + break; + + case "compatibilityOverrides": + if (!addon.compatibilityOverrides) addon.compatibilityOverrides = []; + for (let override of value) { + addon.compatibilityOverrides.push( + this._makeCompatOverride(override) + ); + } + break; + + case "icons": + if (!addon.icons) addon.icons = {}; + for (let size of Object.keys(aObj.icons)) { + addon.icons[size] = aObj.icons[size]; + } + break; + + case "iconURL": + break; + + default: + addon[expectedProperty] = value; + } + } catch (ex) { + logger.warn("Error in parsing property value for " + expectedProperty + " | " + ex); + } + + // delete property from obj to indicate we've already + // handled it. The remaining public properties will + // be stored separately and just passed through to + // be written back to the DB. + delete aObj[expectedProperty]; + } + + // Copy remaining properties to a separate object + // to prevent accidental access on downgraded versions. + // The properties will be merged in the same object + // prior to being written back through toJSON. + for (let remainingProperty of Object.keys(aObj)) { + switch (typeof(aObj[remainingProperty])) { + case "boolean": + case "number": + case "string": + case "object": + // these types are accepted + break; + default: + continue; + } + + if (!remainingProperty.startsWith("_")) + addon._unsupportedProperties[remainingProperty] = + aObj[remainingProperty]; + } + + return addon; + }, + + /** + * Write the in-memory DB to disk, after waiting for + * the DB_BATCH_TIMEOUT_MS timeout. + * + * @return Promise A promise that resolves after the + * write to disk has completed. + */ + _saveDBToDisk: function() { + return this.Writer.saveChanges().then( + null, + e => logger.error("SaveDBToDisk failed", e)); + }, + + /** + * Make a developer object from a vanilla + * JS object from the JSON database + * + * @param aObj + * The JS object to use + * @return The created developer + */ + _makeDeveloper: function(aObj) { + let name = aObj.name; + let url = aObj.url; + return new AddonManagerPrivate.AddonAuthor(name, url); + }, + + /** + * Make a screenshot object from a vanilla + * JS object from the JSON database + * + * @param aObj + * The JS object to use + * @return The created screenshot + */ + _makeScreenshot: function(aObj) { + let url = aObj.url; + let width = aObj.width; + let height = aObj.height; + let thumbnailURL = aObj.thumbnailURL; + let thumbnailWidth = aObj.thumbnailWidth; + let thumbnailHeight = aObj.thumbnailHeight; + let caption = aObj.caption; + return new AddonManagerPrivate.AddonScreenshot(url, width, height, thumbnailURL, + thumbnailWidth, thumbnailHeight, caption); + }, + + /** + * Make a CompatibilityOverride from a vanilla + * JS object from the JSON database + * + * @param aObj + * The JS object to use + * @return The created CompatibilityOverride + */ + _makeCompatOverride: function(aObj) { + let type = aObj.type; + let minVersion = aObj.minVersion; + let maxVersion = aObj.maxVersion; + let appID = aObj.appID; + let appMinVersion = aObj.appMinVersion; + let appMaxVersion = aObj.appMaxVersion; + return new AddonManagerPrivate.AddonCompatibilityOverride(type, + minVersion, + maxVersion, + appID, + appMinVersion, + appMaxVersion); + }, +}; diff --git a/toolkit/mozapps/extensions/internal/AddonRepository_SQLiteMigrator.jsm b/toolkit/mozapps/extensions/internal/AddonRepository_SQLiteMigrator.jsm new file mode 100644 index 0000000000..e3479643be --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonRepository_SQLiteMigrator.jsm @@ -0,0 +1,522 @@ +/* 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 Cu = Components.utils; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/AddonManager.jsm"); +/* globals AddonManagerPrivate*/ +Cu.import("resource://gre/modules/FileUtils.jsm"); + +const KEY_PROFILEDIR = "ProfD"; +const FILE_DATABASE = "addons.sqlite"; +const LAST_DB_SCHEMA = 4; + +// Add-on properties present in the columns of the database +const PROP_SINGLE = ["id", "type", "name", "version", "creator", "description", + "fullDescription", "developerComments", "eula", + "homepageURL", "supportURL", "contributionURL", + "contributionAmount", "averageRating", "reviewCount", + "reviewURL", "totalDownloads", "weeklyDownloads", + "dailyUsers", "sourceURI", "repositoryStatus", "size", + "updateDate"]; + +Cu.import("resource://gre/modules/Log.jsm"); +const LOGGER_ID = "addons.repository.sqlmigrator"; + +// Create a new logger for use by the Addons Repository SQL Migrator +// (Requires AddonManager.jsm) +var logger = Log.repository.getLogger(LOGGER_ID); + +this.EXPORTED_SYMBOLS = ["AddonRepository_SQLiteMigrator"]; + + +this.AddonRepository_SQLiteMigrator = { + + /** + * Migrates data from a previous SQLite version of the + * database to the JSON version. + * + * @param structFunctions an object that contains functions + * to create the various objects used + * in the new JSON format + * @param aCallback A callback to be called when migration + * finishes, with the results in an array + * @returns bool True if a migration will happen (DB was + * found and succesfully opened) + */ + migrate: function(aCallback) { + if (!this._openConnection()) { + this._closeConnection(); + aCallback([]); + return false; + } + + logger.debug("Importing addon repository from previous " + FILE_DATABASE + " storage."); + + this._retrieveStoredData((results) => { + this._closeConnection(); + let resultArray = Object.keys(results).map(k => results[k]); + logger.debug(resultArray.length + " addons imported.") + aCallback(resultArray); + }); + + return true; + }, + + /** + * Synchronously opens a new connection to the database file. + * + * @return bool Whether the DB was opened successfully. + */ + _openConnection: function() { + delete this.connection; + + let dbfile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_DATABASE], true); + if (!dbfile.exists()) + return false; + + try { + this.connection = Services.storage.openUnsharedDatabase(dbfile); + } catch (e) { + return false; + } + + this.connection.executeSimpleSQL("PRAGMA locking_mode = EXCLUSIVE"); + + // Any errors in here should rollback + try { + this.connection.beginTransaction(); + + switch (this.connection.schemaVersion) { + case 0: + return false; + + case 1: + logger.debug("Upgrading database schema to version 2"); + this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN width INTEGER"); + this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN height INTEGER"); + this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN thumbnailWidth INTEGER"); + this.connection.executeSimpleSQL("ALTER TABLE screenshot ADD COLUMN thumbnailHeight INTEGER"); + case 2: + logger.debug("Upgrading database schema to version 3"); + this.connection.createTable("compatibility_override", + "addon_internal_id INTEGER, " + + "num INTEGER, " + + "type TEXT, " + + "minVersion TEXT, " + + "maxVersion TEXT, " + + "appID TEXT, " + + "appMinVersion TEXT, " + + "appMaxVersion TEXT, " + + "PRIMARY KEY (addon_internal_id, num)"); + case 3: + logger.debug("Upgrading database schema to version 4"); + this.connection.createTable("icon", + "addon_internal_id INTEGER, " + + "size INTEGER, " + + "url TEXT, " + + "PRIMARY KEY (addon_internal_id, size)"); + this._createIndices(); + this._createTriggers(); + this.connection.schemaVersion = LAST_DB_SCHEMA; + case LAST_DB_SCHEMA: + break; + default: + return false; + } + this.connection.commitTransaction(); + } catch (e) { + logger.error("Failed to open " + FILE_DATABASE + ". Data import will not happen.", e); + this.logSQLError(this.connection.lastError, this.connection.lastErrorString); + this.connection.rollbackTransaction(); + return false; + } + + return true; + }, + + _closeConnection: function() { + for (let key in this.asyncStatementsCache) { + let stmt = this.asyncStatementsCache[key]; + stmt.finalize(); + } + this.asyncStatementsCache = {}; + + if (this.connection) + this.connection.asyncClose(); + + delete this.connection; + }, + + /** + * Asynchronously retrieve all add-ons from the database, and pass it + * to the specified callback + * + * @param aCallback + * The callback to pass the add-ons back to + */ + _retrieveStoredData: function(aCallback) { + let addons = {}; + + // Retrieve all data from the addon table + let getAllAddons = () => { + this.getAsyncStatement("getAllAddons").executeAsync({ + handleResult: aResults => { + let row = null; + while ((row = aResults.getNextRow())) { + let internal_id = row.getResultByName("internal_id"); + addons[internal_id] = this._makeAddonFromAsyncRow(row); + } + }, + + handleError: this.asyncErrorLogger, + + handleCompletion: function(aReason) { + if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) { + logger.error("Error retrieving add-ons from database. Returning empty results"); + aCallback({}); + return; + } + + getAllDevelopers(); + } + }); + } + + // Retrieve all data from the developer table + let getAllDevelopers = () => { + this.getAsyncStatement("getAllDevelopers").executeAsync({ + handleResult: aResults => { + let row = null; + while ((row = aResults.getNextRow())) { + let addon_internal_id = row.getResultByName("addon_internal_id"); + if (!(addon_internal_id in addons)) { + logger.warn("Found a developer not linked to an add-on in database"); + continue; + } + + let addon = addons[addon_internal_id]; + if (!addon.developers) + addon.developers = []; + + addon.developers.push(this._makeDeveloperFromAsyncRow(row)); + } + }, + + handleError: this.asyncErrorLogger, + + handleCompletion: function(aReason) { + if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) { + logger.error("Error retrieving developers from database. Returning empty results"); + aCallback({}); + return; + } + + getAllScreenshots(); + } + }); + } + + // Retrieve all data from the screenshot table + let getAllScreenshots = () => { + this.getAsyncStatement("getAllScreenshots").executeAsync({ + handleResult: aResults => { + let row = null; + while ((row = aResults.getNextRow())) { + let addon_internal_id = row.getResultByName("addon_internal_id"); + if (!(addon_internal_id in addons)) { + logger.warn("Found a screenshot not linked to an add-on in database"); + continue; + } + + let addon = addons[addon_internal_id]; + if (!addon.screenshots) + addon.screenshots = []; + addon.screenshots.push(this._makeScreenshotFromAsyncRow(row)); + } + }, + + handleError: this.asyncErrorLogger, + + handleCompletion: function(aReason) { + if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) { + logger.error("Error retrieving screenshots from database. Returning empty results"); + aCallback({}); + return; + } + + getAllCompatOverrides(); + } + }); + } + + let getAllCompatOverrides = () => { + this.getAsyncStatement("getAllCompatOverrides").executeAsync({ + handleResult: aResults => { + let row = null; + while ((row = aResults.getNextRow())) { + let addon_internal_id = row.getResultByName("addon_internal_id"); + if (!(addon_internal_id in addons)) { + logger.warn("Found a compatibility override not linked to an add-on in database"); + continue; + } + + let addon = addons[addon_internal_id]; + if (!addon.compatibilityOverrides) + addon.compatibilityOverrides = []; + addon.compatibilityOverrides.push(this._makeCompatOverrideFromAsyncRow(row)); + } + }, + + handleError: this.asyncErrorLogger, + + handleCompletion: function(aReason) { + if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) { + logger.error("Error retrieving compatibility overrides from database. Returning empty results"); + aCallback({}); + return; + } + + getAllIcons(); + } + }); + } + + let getAllIcons = () => { + this.getAsyncStatement("getAllIcons").executeAsync({ + handleResult: aResults => { + let row = null; + while ((row = aResults.getNextRow())) { + let addon_internal_id = row.getResultByName("addon_internal_id"); + if (!(addon_internal_id in addons)) { + logger.warn("Found an icon not linked to an add-on in database"); + continue; + } + + let addon = addons[addon_internal_id]; + let { size, url } = this._makeIconFromAsyncRow(row); + addon.icons[size] = url; + if (size == 32) + addon.iconURL = url; + } + }, + + handleError: this.asyncErrorLogger, + + handleCompletion: function(aReason) { + if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED) { + logger.error("Error retrieving icons from database. Returning empty results"); + aCallback({}); + return; + } + + let returnedAddons = {}; + for (let id in addons) { + let addon = addons[id]; + returnedAddons[addon.id] = addon; + } + aCallback(returnedAddons); + } + }); + } + + // Begin asynchronous process + getAllAddons(); + }, + + // A cache of statements that are used and need to be finalized on shutdown + asyncStatementsCache: {}, + + /** + * Gets a cached async statement or creates a new statement if it doesn't + * already exist. + * + * @param aKey + * A unique key to reference the statement + * @return a mozIStorageAsyncStatement for the SQL corresponding to the + * unique key + */ + getAsyncStatement: function(aKey) { + if (aKey in this.asyncStatementsCache) + return this.asyncStatementsCache[aKey]; + + let sql = this.queries[aKey]; + try { + return this.asyncStatementsCache[aKey] = this.connection.createAsyncStatement(sql); + } catch (e) { + logger.error("Error creating statement " + aKey + " (" + sql + ")"); + throw Components.Exception("Error creating statement " + aKey + " (" + sql + "): " + e, + e.result); + } + }, + + // The queries used by the database + queries: { + getAllAddons: "SELECT internal_id, id, type, name, version, " + + "creator, creatorURL, description, fullDescription, " + + "developerComments, eula, homepageURL, supportURL, " + + "contributionURL, contributionAmount, averageRating, " + + "reviewCount, reviewURL, totalDownloads, weeklyDownloads, " + + "dailyUsers, sourceURI, repositoryStatus, size, updateDate " + + "FROM addon", + + getAllDevelopers: "SELECT addon_internal_id, name, url FROM developer " + + "ORDER BY addon_internal_id, num", + + getAllScreenshots: "SELECT addon_internal_id, url, width, height, " + + "thumbnailURL, thumbnailWidth, thumbnailHeight, caption " + + "FROM screenshot ORDER BY addon_internal_id, num", + + getAllCompatOverrides: "SELECT addon_internal_id, type, minVersion, " + + "maxVersion, appID, appMinVersion, appMaxVersion " + + "FROM compatibility_override " + + "ORDER BY addon_internal_id, num", + + getAllIcons: "SELECT addon_internal_id, size, url FROM icon " + + "ORDER BY addon_internal_id, size", + }, + + /** + * Make add-on structure from an asynchronous row. + * + * @param aRow + * The asynchronous row to use + * @return The created add-on + */ + _makeAddonFromAsyncRow: function(aRow) { + // This is intentionally not an AddonSearchResult object in order + // to allow AddonDatabase._parseAddon to parse it, same as if it + // was read from the JSON database. + + let addon = { icons: {} }; + + for (let prop of PROP_SINGLE) { + addon[prop] = aRow.getResultByName(prop) + } + + return addon; + }, + + /** + * Make a developer from an asynchronous row + * + * @param aRow + * The asynchronous row to use + * @return The created developer + */ + _makeDeveloperFromAsyncRow: function(aRow) { + let name = aRow.getResultByName("name"); + let url = aRow.getResultByName("url") + return new AddonManagerPrivate.AddonAuthor(name, url); + }, + + /** + * Make a screenshot from an asynchronous row + * + * @param aRow + * The asynchronous row to use + * @return The created screenshot + */ + _makeScreenshotFromAsyncRow: function(aRow) { + let url = aRow.getResultByName("url"); + let width = aRow.getResultByName("width"); + let height = aRow.getResultByName("height"); + let thumbnailURL = aRow.getResultByName("thumbnailURL"); + let thumbnailWidth = aRow.getResultByName("thumbnailWidth"); + let thumbnailHeight = aRow.getResultByName("thumbnailHeight"); + let caption = aRow.getResultByName("caption"); + return new AddonManagerPrivate.AddonScreenshot(url, width, height, thumbnailURL, + thumbnailWidth, thumbnailHeight, caption); + }, + + /** + * Make a CompatibilityOverride from an asynchronous row + * + * @param aRow + * The asynchronous row to use + * @return The created CompatibilityOverride + */ + _makeCompatOverrideFromAsyncRow: function(aRow) { + let type = aRow.getResultByName("type"); + let minVersion = aRow.getResultByName("minVersion"); + let maxVersion = aRow.getResultByName("maxVersion"); + let appID = aRow.getResultByName("appID"); + let appMinVersion = aRow.getResultByName("appMinVersion"); + let appMaxVersion = aRow.getResultByName("appMaxVersion"); + return new AddonManagerPrivate.AddonCompatibilityOverride(type, + minVersion, + maxVersion, + appID, + appMinVersion, + appMaxVersion); + }, + + /** + * Make an icon from an asynchronous row + * + * @param aRow + * The asynchronous row to use + * @return An object containing the size and URL of the icon + */ + _makeIconFromAsyncRow: function(aRow) { + let size = aRow.getResultByName("size"); + let url = aRow.getResultByName("url"); + return { size: size, url: url }; + }, + + /** + * A helper function to log an SQL error. + * + * @param aError + * The storage error code associated with the error + * @param aErrorString + * An error message + */ + logSQLError: function(aError, aErrorString) { + logger.error("SQL error " + aError + ": " + aErrorString); + }, + + /** + * A helper function to log any errors that occur during async statements. + * + * @param aError + * A mozIStorageError to log + */ + asyncErrorLogger: function(aError) { + logger.error("Async SQL error " + aError.result + ": " + aError.message); + }, + + /** + * Synchronously creates the triggers in the database. + */ + _createTriggers: function() { + this.connection.executeSimpleSQL("DROP TRIGGER IF EXISTS delete_addon"); + this.connection.executeSimpleSQL("CREATE TRIGGER delete_addon AFTER DELETE " + + "ON addon BEGIN " + + "DELETE FROM developer WHERE addon_internal_id=old.internal_id; " + + "DELETE FROM screenshot WHERE addon_internal_id=old.internal_id; " + + "DELETE FROM compatibility_override WHERE addon_internal_id=old.internal_id; " + + "DELETE FROM icon WHERE addon_internal_id=old.internal_id; " + + "END"); + }, + + /** + * Synchronously creates the indices in the database. + */ + _createIndices: function() { + this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS developer_idx " + + "ON developer (addon_internal_id)"); + this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS screenshot_idx " + + "ON screenshot (addon_internal_id)"); + this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS compatibility_override_idx " + + "ON compatibility_override (addon_internal_id)"); + this.connection.executeSimpleSQL("CREATE INDEX IF NOT EXISTS icon_idx " + + "ON icon (addon_internal_id)"); + } +} diff --git a/toolkit/mozapps/extensions/internal/AddonTestUtils.jsm b/toolkit/mozapps/extensions/internal/AddonTestUtils.jsm new file mode 100644 index 0000000000..bbfb56ad5e --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonTestUtils.jsm @@ -0,0 +1,1232 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +/* eslint "mozilla/no-aArgs": 1 */ +/* eslint "no-unused-vars": [2, {"args": "none", "varsIgnorePattern": "^(Cc|Ci|Cr|Cu|EXPORTED_SYMBOLS)$"}] */ +/* eslint "semi": [2, "always"] */ +/* eslint "valid-jsdoc": [2, {requireReturn: false}] */ + +var EXPORTED_SYMBOLS = ["AddonTestUtils", "MockAsyncShutdown"]; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +const CERTDB_CONTRACTID = "@mozilla.org/security/x509certdb;1"; +const CERTDB_CID = Components.ID("{fb0bbc5c-452e-4783-b32c-80124693d871}"); + + +Cu.importGlobalProperties(["fetch", "TextEncoder"]); + +Cu.import("resource://gre/modules/AsyncShutdown.jsm"); +Cu.import("resource://gre/modules/FileUtils.jsm"); +Cu.import("resource://gre/modules/NetUtil.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/Task.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +const {EventEmitter} = Cu.import("resource://devtools/shared/event-emitter.js", {}); +const {OS} = Cu.import("resource://gre/modules/osfile.jsm", {}); + +XPCOMUtils.defineLazyModuleGetter(this, "Extension", + "resource://gre/modules/Extension.jsm"); + +XPCOMUtils.defineLazyServiceGetter(this, "rdfService", + "@mozilla.org/rdf/rdf-service;1", "nsIRDFService"); +XPCOMUtils.defineLazyServiceGetter(this, "uuidGen", + "@mozilla.org/uuid-generator;1", "nsIUUIDGenerator"); + + +XPCOMUtils.defineLazyGetter(this, "AppInfo", () => { + let AppInfo = {}; + Cu.import("resource://testing-common/AppInfo.jsm", AppInfo); + return AppInfo; +}); + + +const ArrayBufferInputStream = Components.Constructor( + "@mozilla.org/io/arraybuffer-input-stream;1", + "nsIArrayBufferInputStream", "setData"); + +const nsFile = Components.Constructor( + "@mozilla.org/file/local;1", + "nsIFile", "initWithPath"); + +const RDFXMLParser = Components.Constructor( + "@mozilla.org/rdf/xml-parser;1", + "nsIRDFXMLParser", "parseString"); + +const RDFDataSource = Components.Constructor( + "@mozilla.org/rdf/datasource;1?name=in-memory-datasource", + "nsIRDFDataSource"); + +const ZipReader = Components.Constructor( + "@mozilla.org/libjar/zip-reader;1", + "nsIZipReader", "open"); + +const ZipWriter = Components.Constructor( + "@mozilla.org/zipwriter;1", + "nsIZipWriter", "open"); + + +// We need some internal bits of AddonManager +var AMscope = Cu.import("resource://gre/modules/AddonManager.jsm", {}); +var {AddonManager, AddonManagerPrivate} = AMscope; + + +// Mock out AddonManager's reference to the AsyncShutdown module so we can shut +// down AddonManager from the test +var MockAsyncShutdown = { + hook: null, + status: null, + profileBeforeChange: { + addBlocker: function(name, blocker, options) { + MockAsyncShutdown.hook = blocker; + MockAsyncShutdown.status = options.fetchState; + } + }, + // We can use the real Barrier + Barrier: AsyncShutdown.Barrier, +}; + +AMscope.AsyncShutdown = MockAsyncShutdown; + + +/** + * Escapes any occurances of &, ", < or > with XML entities. + * + * @param {string} str + * The string to escape. + * @return {string} The escaped string. + */ +function escapeXML(str) { + let replacements = {"&": "&", '"': """, "'": "'", "<": "<", ">": ">"}; + return String(str).replace(/[&"''<>]/g, m => replacements[m]); +} + +/** + * A tagged template function which escapes any XML metacharacters in + * interpolated values. + * + * @param {Array} strings + * An array of literal strings extracted from the templates. + * @param {Array} values + * An array of interpolated values extracted from the template. + * @returns {string} + * The result of the escaped values interpolated with the literal + * strings. + */ +function escaped(strings, ...values) { + let result = []; + + for (let [i, string] of strings.entries()) { + result.push(string); + if (i < values.length) + result.push(escapeXML(values[i])); + } + + return result.join(""); +} + + +class AddonsList { + constructor(extensionsINI) { + this.multiprocessIncompatibleIDs = new Set(); + + if (!extensionsINI.exists()) { + this.extensions = []; + this.themes = []; + return; + } + + let factory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"] + .getService(Ci.nsIINIParserFactory); + + let parser = factory.createINIParser(extensionsINI); + + function readDirectories(section) { + var dirs = []; + var keys = parser.getKeys(section); + for (let key of XPCOMUtils.IterStringEnumerator(keys)) { + let descriptor = parser.getString(section, key); + + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + try { + file.persistentDescriptor = descriptor; + } catch (e) { + // Throws if the directory doesn't exist, we can ignore this since the + // platform will too. + continue; + } + dirs.push(file); + } + return dirs; + } + + this.extensions = readDirectories("ExtensionDirs"); + this.themes = readDirectories("ThemeDirs"); + + var keys = parser.getKeys("MultiprocessIncompatibleExtensions"); + for (let key of XPCOMUtils.IterStringEnumerator(keys)) { + let id = parser.getString("MultiprocessIncompatibleExtensions", key); + this.multiprocessIncompatibleIDs.add(id); + } + } + + hasItem(type, dir, id) { + var path = dir.clone(); + path.append(id); + + var xpiPath = dir.clone(); + xpiPath.append(`${id}.xpi`); + + return this[type].some(file => { + if (!file.exists()) + throw new Error(`Non-existent path found in extensions.ini: ${file.path}`); + + if (file.isDirectory()) + return file.equals(path); + if (file.isFile()) + return file.equals(xpiPath); + return false; + }); + } + + isMultiprocessIncompatible(id) { + return this.multiprocessIncompatibleIDs.has(id); + } + + hasTheme(dir, id) { + return this.hasItem("themes", dir, id); + } + + hasExtension(dir, id) { + return this.hasItem("extensions", dir, id); + } +} + +var AddonTestUtils = { + addonIntegrationService: null, + addonsList: null, + appInfo: null, + extensionsINI: null, + testUnpacked: false, + useRealCertChecks: false, + + init(testScope) { + this.testScope = testScope; + + // Get the profile directory for tests to use. + this.profileDir = testScope.do_get_profile(); + + this.extensionsINI = this.profileDir.clone(); + this.extensionsINI.append("extensions.ini"); + + // Register a temporary directory for the tests. + this.tempDir = this.profileDir.clone(); + this.tempDir.append("temp"); + this.tempDir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY); + this.registerDirectory("TmpD", this.tempDir); + + // Create a replacement app directory for the tests. + const appDirForAddons = this.profileDir.clone(); + appDirForAddons.append("appdir-addons"); + appDirForAddons.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY); + this.registerDirectory("XREAddonAppDir", appDirForAddons); + + + // Enable more extensive EM logging + Services.prefs.setBoolPref("extensions.logging.enabled", true); + + // By default only load extensions from the profile install location + Services.prefs.setIntPref("extensions.enabledScopes", AddonManager.SCOPE_PROFILE); + + // By default don't disable add-ons from any scope + Services.prefs.setIntPref("extensions.autoDisableScopes", 0); + + // By default, don't cache add-ons in AddonRepository.jsm + Services.prefs.setBoolPref("extensions.getAddons.cache.enabled", false); + + // Disable the compatibility updates window by default + Services.prefs.setBoolPref("extensions.showMismatchUI", false); + + // Point update checks to the local machine for fast failures + Services.prefs.setCharPref("extensions.update.url", "http://127.0.0.1/updateURL"); + Services.prefs.setCharPref("extensions.update.background.url", "http://127.0.0.1/updateBackgroundURL"); + Services.prefs.setCharPref("extensions.blocklist.url", "http://127.0.0.1/blocklistURL"); + Services.prefs.setCharPref("services.settings.server", "http://localhost/dummy-kinto/v1"); + + // By default ignore bundled add-ons + Services.prefs.setBoolPref("extensions.installDistroAddons", false); + + // By default don't check for hotfixes + Services.prefs.setCharPref("extensions.hotfix.id", ""); + + // Ensure signature checks are enabled by default + Services.prefs.setBoolPref("xpinstall.signatures.required", true); + + + // Write out an empty blocklist.xml file to the profile to ensure nothing + // is blocklisted by default + var blockFile = OS.Path.join(this.profileDir.path, "blocklist.xml"); + + var data = "\n" + + "\n" + + "\n"; + + this.awaitPromise(OS.File.writeAtomic(blockFile, new TextEncoder().encode(data))); + + + // Make sure that a given path does not exist + function pathShouldntExist(file) { + if (file.exists()) { + throw new Error(`Test cleanup: path ${file.path} exists when it should not`); + } + } + + testScope.do_register_cleanup(() => { + for (let file of this.tempXPIs) { + if (file.exists()) + file.remove(false); + } + + // Check that the temporary directory is empty + var dirEntries = this.tempDir.directoryEntries + .QueryInterface(Ci.nsIDirectoryEnumerator); + var entries = []; + while (dirEntries.hasMoreElements()) + entries.push(dirEntries.nextFile.leafName); + if (entries.length) + throw new Error(`Found unexpected files in temporary directory: ${entries.join(", ")}`); + + dirEntries.close(); + + try { + appDirForAddons.remove(true); + } catch (ex) { + testScope.do_print(`Got exception removing addon app dir: ${ex}`); + } + + // ensure no leftover files in the system addon upgrade location + let featuresDir = this.profileDir.clone(); + featuresDir.append("features"); + // upgrade directories will be in UUID folders under features/ + let systemAddonDirs = []; + if (featuresDir.exists()) { + let featuresDirEntries = featuresDir.directoryEntries + .QueryInterface(Ci.nsIDirectoryEnumerator); + while (featuresDirEntries.hasMoreElements()) { + let entry = featuresDirEntries.getNext(); + entry.QueryInterface(Components.interfaces.nsIFile); + systemAddonDirs.push(entry); + } + + systemAddonDirs.map(dir => { + dir.append("stage"); + pathShouldntExist(dir); + }); + } + + // ensure no leftover files in the user addon location + let testDir = this.profileDir.clone(); + testDir.append("extensions"); + testDir.append("trash"); + pathShouldntExist(testDir); + + testDir.leafName = "staged"; + pathShouldntExist(testDir); + + return this.promiseShutdownManager(); + }); + }, + + /** + * Helper to spin the event loop until a promise resolves or rejects + * + * @param {Promise} promise + * The promise to wait on. + * @returns {*} The promise's resolution value. + * @throws The promise's rejection value, if it rejects. + */ + awaitPromise(promise) { + let done = false; + let result; + let error; + promise.then( + val => { result = val; }, + err => { error = err; } + ).then(() => { + done = true; + }); + + while (!done) + Services.tm.mainThread.processNextEvent(true); + + if (error !== undefined) + throw error; + return result; + }, + + createAppInfo(ID, name, version, platformVersion = "1.0") { + AppInfo.updateAppInfo({ + ID, name, version, platformVersion, + crashReporter: true, + extraProps: { + browserTabsRemoteAutostart: false, + }, + }); + this.appInfo = AppInfo.getAppInfo(); + }, + + getManifestURI(file) { + if (file.isDirectory()) { + file.append("install.rdf"); + if (file.exists()) { + return NetUtil.newURI(file); + } + + file.leafName = "manifest.json"; + if (file.exists()) + return NetUtil.newURI(file); + + throw new Error("No manifest file present"); + } + + let zip = ZipReader(file); + try { + let uri = NetUtil.newURI(file); + + if (zip.hasEntry("install.rdf")) { + return NetUtil.newURI(`jar:${uri.spec}!/install.rdf`); + } + + if (zip.hasEntry("manifest.json")) { + return NetUtil.newURI(`jar:${uri.spec}!/manifest.json`); + } + + throw new Error("No manifest file present"); + } finally { + zip.close(); + } + }, + + getIDFromManifest: Task.async(function*(manifestURI) { + let body = yield fetch(manifestURI.spec); + + if (manifestURI.spec.endsWith(".rdf")) { + let data = yield body.text(); + + let ds = new RDFDataSource(); + new RDFXMLParser(ds, manifestURI, data); + + let rdfID = ds.GetTarget(rdfService.GetResource("urn:mozilla:install-manifest"), + rdfService.GetResource("http://www.mozilla.org/2004/em-rdf#id"), + true); + return rdfID.QueryInterface(Ci.nsIRDFLiteral).Value; + } + + let manifest = yield body.json(); + try { + return manifest.applications.gecko.id; + } catch (e) { + // IDs for WebExtensions are extracted from the certificate when + // not present in the manifest, so just generate a random one. + return uuidGen.generateUUID().number; + } + }), + + overrideCertDB() { + // Unregister the real database. This only works because the add-ons manager + // hasn't started up and grabbed the certificate database yet. + let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar); + let factory = registrar.getClassObject(CERTDB_CID, Ci.nsIFactory); + registrar.unregisterFactory(CERTDB_CID, factory); + + // Get the real DB + let realCertDB = factory.createInstance(null, Ci.nsIX509CertDB); + + + let verifyCert = Task.async(function*(file, result, cert, callback) { + if (result == Cr.NS_ERROR_SIGNED_JAR_NOT_SIGNED && + !this.useRealCertChecks && callback.wrappedJSObject) { + // Bypassing XPConnect allows us to create a fake x509 certificate from JS + callback = callback.wrappedJSObject; + + try { + let manifestURI = this.getManifestURI(file); + + let id = yield this.getIDFromManifest(manifestURI); + + let fakeCert = {commonName: id}; + + return [callback, Cr.NS_OK, fakeCert]; + } catch (e) { + // If there is any error then just pass along the original results + } finally { + // Make sure to close the open zip file or it will be locked. + if (file.isFile()) + Services.obs.notifyObservers(file, "flush-cache-entry", "cert-override"); + } + } + + return [callback, result, cert]; + }).bind(this); + + + function FakeCertDB() { + for (let property of Object.keys(realCertDB)) { + if (property in this) + continue; + + if (typeof realCertDB[property] == "function") + this[property] = realCertDB[property].bind(realCertDB); + } + } + FakeCertDB.prototype = { + openSignedAppFileAsync(root, file, callback) { + // First try calling the real cert DB + realCertDB.openSignedAppFileAsync(root, file, (result, zipReader, cert) => { + verifyCert(file.clone(), result, cert, callback) + .then(([callback, result, cert]) => { + callback.openSignedAppFileFinished(result, zipReader, cert); + }); + }); + }, + + verifySignedDirectoryAsync(root, dir, callback) { + // First try calling the real cert DB + realCertDB.verifySignedDirectoryAsync(root, dir, (result, cert) => { + verifyCert(dir.clone(), result, cert, callback) + .then(([callback, result, cert]) => { + callback.verifySignedDirectoryFinished(result, cert); + }); + }); + }, + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIX509CertDB]), + }; + + let certDBFactory = XPCOMUtils.generateSingletonFactory(FakeCertDB); + registrar.registerFactory(CERTDB_CID, "CertDB", + CERTDB_CONTRACTID, certDBFactory); + }, + + /** + * Starts up the add-on manager as if it was started by the application. + * + * @param {boolean} [appChanged = true] + * An optional boolean parameter to simulate the case where the + * application has changed version since the last run. If not passed it + * defaults to true + * @returns {Promise} + * Resolves when the add-on manager's startup has completed. + */ + promiseStartupManager(appChanged = true) { + if (this.addonIntegrationService) + throw new Error("Attempting to startup manager that was already started."); + + if (appChanged && this.extensionsINI.exists()) + this.extensionsINI.remove(true); + + this.addonIntegrationService = Cc["@mozilla.org/addons/integration;1"] + .getService(Ci.nsIObserver); + + this.addonIntegrationService.observe(null, "addons-startup", null); + + this.emit("addon-manager-started"); + + // Load the add-ons list as it was after extension registration + this.loadAddonsList(); + + return Promise.resolve(); + }, + + promiseShutdownManager() { + if (!this.addonIntegrationService) + return Promise.resolve(false); + + Services.obs.notifyObservers(null, "quit-application-granted", null); + return MockAsyncShutdown.hook() + .then(() => { + this.emit("addon-manager-shutdown"); + + this.addonIntegrationService = null; + + // Load the add-ons list as it was after application shutdown + this.loadAddonsList(); + + // Clear any crash report annotations + this.appInfo.annotations = {}; + + // Force the XPIProvider provider to reload to better + // simulate real-world usage. + let XPIscope = Cu.import("resource://gre/modules/addons/XPIProvider.jsm"); + // This would be cleaner if I could get it as the rejection reason from + // the AddonManagerInternal.shutdown() promise + let shutdownError = XPIscope.XPIProvider._shutdownError; + + AddonManagerPrivate.unregisterProvider(XPIscope.XPIProvider); + Cu.unload("resource://gre/modules/addons/XPIProvider.jsm"); + + if (shutdownError) + throw shutdownError; + + return true; + }); + }, + + promiseRestartManager(newVersion) { + return this.promiseShutdownManager() + .then(() => { + if (newVersion) + this.appInfo.version = newVersion; + + return this.promiseStartupManager(!!newVersion); + }); + }, + + loadAddonsList() { + this.addonsList = new AddonsList(this.extensionsINI); + }, + + /** + * Creates an update.rdf structure as a string using for the update data passed. + * + * @param {Object} data + * The update data as a JS object. Each property name is an add-on ID, + * the property value is an array of each version of the add-on. Each + * array value is a JS object containing the data for the version, at + * minimum a "version" and "targetApplications" property should be + * included to create a functional update manifest. + * @return {string} The update.rdf structure as a string. + */ + createUpdateRDF(data) { + var rdf = '\n'; + rdf += '\n'; + + for (let addon in data) { + rdf += escaped` \n`; + + for (let versionData of data[addon]) { + rdf += '
  • \n'; + rdf += this._writeProps(versionData, ["version", "multiprocessCompatible"], + ` `); + for (let app of versionData.targetApplications || []) { + rdf += " \n"; + rdf += this._writeProps(app, ["id", "minVersion", "maxVersion", "updateLink", "updateHash"], + ` `); + rdf += " \n"; + } + rdf += '
    • \n'; + } + rdf += '     \n'; + } + rdf += "    \n"; + + return rdf; + }, + + _writeProps(obj, props, indent = " ") { + let items = []; + for (let prop of props) { + if (prop in obj) + items.push(escaped`${indent}${obj[prop]}\n`); + } + return items.join(""); + }, + + _writeArrayProps(obj, props, indent = " ") { + let items = []; + for (let prop of props) { + for (let val of obj[prop] || []) + items.push(escaped`${indent}${val}\n`); + } + return items.join(""); + }, + + _writeLocaleStrings(data) { + let items = []; + + items.push(this._writeProps(data, ["name", "description", "creator", "homepageURL"])); + items.push(this._writeArrayProps(data, ["developer", "translator", "contributor"])); + + return items.join(""); + }, + + createInstallRDF(data) { + var rdf = '\n'; + rdf += '\n'; + + rdf += '\n'; + + let props = ["id", "version", "type", "internalName", "updateURL", "updateKey", + "optionsURL", "optionsType", "aboutURL", "iconURL", "icon64URL", + "skinnable", "bootstrap", "unpack", "strictCompatibility", + "multiprocessCompatible", "hasEmbeddedWebExtension"]; + rdf += this._writeProps(data, props); + + rdf += this._writeLocaleStrings(data); + + for (let platform of data.targetPlatforms || []) + rdf += escaped`${platform}\n`; + + for (let app of data.targetApplications || []) { + rdf += "\n"; + rdf += this._writeProps(app, ["id", "minVersion", "maxVersion"]); + rdf += "\n"; + } + + for (let localized of data.localized || []) { + rdf += "\n"; + rdf += this._writeArrayProps(localized, ["locale"]); + rdf += this._writeLocaleStrings(localized); + rdf += "\n"; + } + + for (let dep of data.dependencies || []) + rdf += escaped`\n`; + + rdf += "\n\n"; + return rdf; + }, + + /** + * Recursively create all directories upto and including the given + * path, if they do not exist. + * + * @param {string} path The path of the directory to create. + * @returns {Promise} Resolves when all directories have been created. + */ + recursiveMakeDir(path) { + let paths = []; + for (let lastPath; path != lastPath; lastPath = path, path = OS.Path.dirname(path)) + paths.push(path); + + return Promise.all(paths.reverse().map(path => + OS.File.makeDir(path, {ignoreExisting: true}).catch(() => {}))); + }, + + /** + * Writes the given data to a file in the given zip file. + * + * @param {string|nsIFile} zipFile + * The zip file to write to. + * @param {Object} files + * An object containing filenames and the data to write to the + * corresponding paths in the zip file. + * @param {integer} [flags = 0] + * Additional flags to open the file with. + */ + writeFilesToZip(zipFile, files, flags = 0) { + if (typeof zipFile == "string") + zipFile = nsFile(zipFile); + + var zipW = ZipWriter(zipFile, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE | flags); + + for (let [path, data] of Object.entries(files)) { + if (!(data instanceof ArrayBuffer)) + data = new TextEncoder("utf-8").encode(data).buffer; + + let stream = ArrayBufferInputStream(data, 0, data.byteLength); + + // Note these files are being created in the XPI archive with date "0" which is 1970-01-01. + zipW.addEntryStream(path, 0, Ci.nsIZipWriter.COMPRESSION_NONE, + stream, false); + } + + zipW.close(); + }, + + promiseWriteFilesToZip: Task.async(function*(zip, files, flags) { + yield this.recursiveMakeDir(OS.Path.dirname(zip)); + + this.writeFilesToZip(zip, files, flags); + + return Promise.resolve(nsFile(zip)); + }), + + promiseWriteFilesToDir: Task.async(function*(dir, files) { + yield this.recursiveMakeDir(dir); + + for (let [path, data] of Object.entries(files)) { + path = path.split("/"); + let leafName = path.pop(); + + // Create parent directories, if necessary. + let dirPath = dir; + for (let subDir of path) { + dirPath = OS.Path.join(dirPath, subDir); + yield OS.Path.makeDir(dirPath, {ignoreExisting: true}); + } + + if (typeof data == "string") + data = new TextEncoder("utf-8").encode(data); + + yield OS.File.writeAtomic(OS.Path.join(dirPath, leafName), data); + } + + return nsFile(dir); + }), + + promiseWriteFilesToExtension(dir, id, files, unpacked = this.testUnpacked) { + if (typeof files["install.rdf"] === "object") + files["install.rdf"] = this.createInstallRDF(files["install.rdf"]); + + if (unpacked) { + let path = OS.Path.join(dir, id); + + return this.promiseWriteFilesToDir(path, files); + } + + let xpi = OS.Path.join(dir, `${id}.xpi`); + + return this.promiseWriteFilesToZip(xpi, files); + }, + + tempXPIs: [], + /** + * Creates an XPI file for some manifest data in the temporary directory and + * returns the nsIFile for it. The file will be deleted when the test completes. + * + * @param {object} files + * The object holding data about the add-on + * @return {nsIFile} A file pointing to the created XPI file + */ + createTempXPIFile(files) { + var file = this.tempDir.clone(); + let uuid = uuidGen.generateUUID().number.slice(1, -1); + file.append(`${uuid}.xpi`); + + this.tempXPIs.push(file); + + if (typeof files["install.rdf"] === "object") + files["install.rdf"] = this.createInstallRDF(files["install.rdf"]); + + this.writeFilesToZip(file.path, files); + return file; + }, + + /** + * Creates an XPI file for some WebExtension data in the temporary directory and + * returns the nsIFile for it. The file will be deleted when the test completes. + * + * @param {Object} data + * The object holding data about the add-on, as expected by + * |Extension.generateXPI|. + * @return {nsIFile} A file pointing to the created XPI file + */ + createTempWebExtensionFile(data) { + let file = Extension.generateXPI(data); + this.tempXPIs.push(file); + return file; + }, + + /** + * Creates an extension proxy file. + * See: https://developer.mozilla.org/en-US/Add-ons/Setting_up_extension_development_environment#Firefox_extension_proxy_file + * + * @param {nsIFile} dir + * The directory to add the proxy file to. + * @param {nsIFile} addon + * An nsIFile for the add-on file that this is a proxy file for. + * @param {string} id + * A string to use for the add-on ID. + * @returns {Promise} Resolves when the file has been created. + */ + promiseWriteProxyFileToDir(dir, addon, id) { + let files = { + [id]: addon.path, + }; + + return this.promiseWriteFilesToDir(dir.path, files); + }, + + /** + * Manually installs an XPI file into an install location by either copying the + * XPI there or extracting it depending on whether unpacking is being tested + * or not. + * + * @param {nsIFile} xpiFile + * The XPI file to install. + * @param {nsIFile} installLocation + * The install location (an nsIFile) to install into. + * @param {string} id + * The ID to install as. + * @param {boolean} [unpacked = this.testUnpacked] + * If true, install as an unpacked directory, rather than a + * packed XPI. + * @returns {nsIFile} + * A file pointing to the installed location of the XPI file or + * unpacked directory. + */ + manuallyInstall(xpiFile, installLocation, id, unpacked = this.testUnpacked) { + if (unpacked) { + let dir = installLocation.clone(); + dir.append(id); + dir.create(Ci.nsIFile.DIRECTORY_TYPE, FileUtils.PERMS_DIRECTORY); + + let zip = ZipReader(xpiFile); + let entries = zip.findEntries(null); + while (entries.hasMore()) { + let entry = entries.getNext(); + let target = dir.clone(); + for (let part of entry.split("/")) + target.append(part); + zip.extract(entry, target); + } + zip.close(); + + return dir; + } + + let target = installLocation.clone(); + target.append(`${id}.xpi`); + xpiFile.copyTo(target.parent, target.leafName); + return target; + }, + + /** + * Manually uninstalls an add-on by removing its files from the install + * location. + * + * @param {nsIFile} installLocation + * The nsIFile of the install location to remove from. + * @param {string} id + * The ID of the add-on to remove. + * @param {boolean} [unpacked = this.testUnpacked] + * If true, uninstall an unpacked directory, rather than a + * packed XPI. + */ + manuallyUninstall(installLocation, id, unpacked = this.testUnpacked) { + let file = this.getFileForAddon(installLocation, id, unpacked); + + // In reality because the app is restarted a flush isn't necessary for XPIs + // removed outside the app, but for testing we must flush manually. + if (file.isFile()) + Services.obs.notifyObservers(file, "flush-cache-entry", null); + + file.remove(true); + }, + + /** + * Gets the nsIFile for where an add-on is installed. It may point to a file or + * a directory depending on whether add-ons are being installed unpacked or not. + * + * @param {nsIFile} dir + * The nsIFile for the install location + * @param {string} id + * The ID of the add-on + * @param {boolean} [unpacked = this.testUnpacked] + * If true, return the path to an unpacked directory, rather than a + * packed XPI. + * @returns {nsIFile} + * A file pointing to the XPI file or unpacked directory where + * the add-on should be installed. + */ + getFileForAddon(dir, id, unpacked = this.testUnpacked) { + dir = dir.clone(); + if (unpacked) + dir.append(id); + else + dir.append(`${id}.xpi`); + return dir; + }, + + /** + * Sets the last modified time of the extension, usually to trigger an update + * of its metadata. If the extension is unpacked, this function assumes that + * the extension contains only the install.rdf file. + * + * @param {nsIFile} ext A file pointing to either the packed extension or its unpacked directory. + * @param {number} time The time to which we set the lastModifiedTime of the extension + * + * @deprecated Please use promiseSetExtensionModifiedTime instead + */ + setExtensionModifiedTime(ext, time) { + ext.lastModifiedTime = time; + if (ext.isDirectory()) { + let entries = ext.directoryEntries + .QueryInterface(Ci.nsIDirectoryEnumerator); + while (entries.hasMoreElements()) + this.setExtensionModifiedTime(entries.nextFile, time); + entries.close(); + } + }, + + promiseSetExtensionModifiedTime: Task.async(function*(path, time) { + yield OS.File.setDates(path, time, time); + + let iterator = new OS.File.DirectoryIterator(path); + try { + yield iterator.forEach(entry => { + return this.promiseSetExtensionModifiedTime(entry.path, time); + }); + } catch (ex) { + if (ex instanceof OS.File.Error) + return; + throw ex; + } finally { + iterator.close().catch(() => {}); + } + }), + + registerDirectory(key, dir) { + var dirProvider = { + getFile(prop, persistent) { + persistent.value = false; + if (prop == key) + return dir.clone(); + return null; + }, + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIDirectoryServiceProvider]), + }; + Services.dirsvc.registerProvider(dirProvider); + }, + + /** + * Returns a promise that resolves when the given add-on event is fired. The + * resolved value is an array of arguments passed for the event. + * + * @param {string} event + * The name of the AddonListener event handler method for which + * an event is expected. + * @returns {Promise} + * Resolves to an array containing the event handler's + * arguments the first time it is called. + */ + promiseAddonEvent(event) { + return new Promise(resolve => { + let listener = { + [event](...args) { + AddonManager.removeAddonListener(listener); + resolve(args); + }, + }; + + AddonManager.addAddonListener(listener); + }); + }, + + /** + * A helper method to install AddonInstall and wait for completion. + * + * @param {AddonInstall} install + * The add-on to install. + * @returns {Promise} + * Resolves when the install completes, either successfully or + * in failure. + */ + promiseCompleteInstall(install) { + let listener; + return new Promise(resolve => { + listener = { + onDownloadFailed: resolve, + onDownloadCancelled: resolve, + onInstallFailed: resolve, + onInstallCancelled: resolve, + onInstallEnded: resolve, + onInstallPostponed: resolve, + }; + + install.addListener(listener); + install.install(); + }).then(() => { + install.removeListener(listener); + }); + }, + + /** + * A helper method to install a file. + * + * @param {nsIFile} file + * The file to install + * @param {boolean} [ignoreIncompatible = false] + * Optional parameter to ignore add-ons that are incompatible + * with the application + * @returns {Promise} + * Resolves when the install has completed. + */ + promiseInstallFile(file, ignoreIncompatible = false) { + return new Promise((resolve, reject) => { + AddonManager.getInstallForFile(file, install => { + if (!install) + reject(new Error(`No AddonInstall created for ${file.path}`)); + else if (install.state != AddonManager.STATE_DOWNLOADED) + reject(new Error(`Expected file to be downloaded for install of ${file.path}`)); + else if (ignoreIncompatible && install.addon.appDisabled) + resolve(); + else + resolve(this.promiseCompleteInstall(install)); + }); + }); + }, + + /** + * A helper method to install an array of files. + * + * @param {Iterable} files + * The files to install + * @param {boolean} [ignoreIncompatible = false] + * Optional parameter to ignore add-ons that are incompatible + * with the application + * @returns {Promise} + * Resolves when the installs have completed. + */ + promiseInstallAllFiles(files, ignoreIncompatible = false) { + return Promise.all(Array.from( + files, + file => this.promiseInstallFile(file, ignoreIncompatible))); + }, + + promiseCompleteAllInstalls(installs) { + return Promise.all(Array.from(installs, this.promiseCompleteInstall)); + }, + + /** + * A promise-based variant of AddonManager.getAddonsByIDs. + * + * @param {Array} list + * As the first argument of AddonManager.getAddonsByIDs + * @return {Promise>} + * Resolves to the array of add-ons for the given IDs. + */ + promiseAddonsByIDs(list) { + return new Promise(resolve => AddonManager.getAddonsByIDs(list, resolve)); + }, + + /** + * A promise-based variant of AddonManager.getAddonByID. + * + * @param {string} id + * The ID of the add-on. + * @return {Promise} + * Resolves to the add-on with the given ID. + */ + promiseAddonByID(id) { + return new Promise(resolve => AddonManager.getAddonByID(id, resolve)); + }, + + /** + * Returns a promise that will be resolved when an add-on update check is + * complete. The value resolved will be an AddonInstall if a new version was + * found. + * + * @param {object} addon The add-on to find updates for. + * @param {integer} reason The type of update to find. + * @return {Promise} an object containing information about the update. + */ + promiseFindAddonUpdates(addon, reason = AddonManager.UPDATE_WHEN_PERIODIC_UPDATE) { + let equal = this.testScope.equal; + return new Promise((resolve, reject) => { + let result = {}; + addon.findUpdates({ + onNoCompatibilityUpdateAvailable: function(addon2) { + if ("compatibilityUpdate" in result) { + throw new Error("Saw multiple compatibility update events"); + } + equal(addon, addon2, "onNoCompatibilityUpdateAvailable"); + result.compatibilityUpdate = false; + }, + + onCompatibilityUpdateAvailable: function(addon2) { + if ("compatibilityUpdate" in result) { + throw new Error("Saw multiple compatibility update events"); + } + equal(addon, addon2, "onCompatibilityUpdateAvailable"); + result.compatibilityUpdate = true; + }, + + onNoUpdateAvailable: function(addon2) { + if ("updateAvailable" in result) { + throw new Error("Saw multiple update available events"); + } + equal(addon, addon2, "onNoUpdateAvailable"); + result.updateAvailable = false; + }, + + onUpdateAvailable: function(addon2, install) { + if ("updateAvailable" in result) { + throw new Error("Saw multiple update available events"); + } + equal(addon, addon2, "onUpdateAvailable"); + result.updateAvailable = install; + }, + + onUpdateFinished: function(addon2, error) { + equal(addon, addon2, "onUpdateFinished"); + if (error == AddonManager.UPDATE_STATUS_NO_ERROR) { + resolve(result); + } else { + result.error = error; + reject(result); + } + } + }, reason); + }); + }, + + /** + * A promise-based variant of AddonManager.getAddonsWithOperationsByTypes + * + * @param {Array} types + * The first argument to AddonManager.getAddonsWithOperationsByTypes + * @return {Promise>} + * Resolves to an array of add-ons with the given operations + * pending. + */ + promiseAddonsWithOperationsByTypes(types) { + return new Promise(resolve => AddonManager.getAddonsWithOperationsByTypes(types, resolve)); + }, + + /** + * Monitors console output for the duration of a task, and returns a promise + * which resolves to a tuple containing a list of all console messages + * generated during the task's execution, and the result of the task itself. + * + * @param {function} task + * The task to run while monitoring console output. May be + * either a generator function, per Task.jsm, or an ordinary + * function which returns promose. + * @return {Promise<[Array, *]>} + * Resolves to an object containing a `messages` property, with + * the array of console messages emitted during the execution + * of the task, and a `result` property, containing the task's + * return value. + */ + promiseConsoleOutput: Task.async(function*(task) { + const DONE = "=== xpcshell test console listener done ==="; + + let listener, messages = []; + let awaitListener = new Promise(resolve => { + listener = msg => { + if (msg == DONE) { + resolve(); + } else { + msg instanceof Ci.nsIScriptError; + messages.push(msg); + } + }; + }); + + Services.console.registerListener(listener); + try { + let result = yield task(); + + Services.console.logStringMessage(DONE); + yield awaitListener; + + return {messages, result}; + } finally { + Services.console.unregisterListener(listener); + } + }), +}; + +for (let [key, val] of Object.entries(AddonTestUtils)) { + if (typeof val == "function") + AddonTestUtils[key] = val.bind(AddonTestUtils); +} + +EventEmitter.decorate(AddonTestUtils); diff --git a/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm b/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm new file mode 100644 index 0000000000..63c16737c3 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm @@ -0,0 +1,934 @@ +/* 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/. */ + +/** + * The AddonUpdateChecker is responsible for retrieving the update information + * from an add-on's remote update manifest. + */ + +"use strict"; + +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cu = Components.utils; + +this.EXPORTED_SYMBOLS = [ "AddonUpdateChecker" ]; + +const TIMEOUT = 60 * 1000; +const PREFIX_NS_RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"; +const PREFIX_NS_EM = "http://www.mozilla.org/2004/em-rdf#"; +const PREFIX_ITEM = "urn:mozilla:item:"; +const PREFIX_EXTENSION = "urn:mozilla:extension:"; +const PREFIX_THEME = "urn:mozilla:theme:"; +const TOOLKIT_ID = "toolkit@mozilla.org" +const XMLURI_PARSE_ERROR = "http://www.mozilla.org/newlayout/xml/parsererror.xml" + +const PREF_UPDATE_REQUIREBUILTINCERTS = "extensions.update.requireBuiltInCerts"; + +Components.utils.import("resource://gre/modules/Services.jsm"); +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "AddonManager", + "resource://gre/modules/AddonManager.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "AddonManagerPrivate", + "resource://gre/modules/AddonManager.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository", + "resource://gre/modules/addons/AddonRepository.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ServiceRequest", + "resource://gre/modules/ServiceRequest.jsm"); + + +// Shared code for suppressing bad cert dialogs. +XPCOMUtils.defineLazyGetter(this, "CertUtils", function() { + let certUtils = {}; + Components.utils.import("resource://gre/modules/CertUtils.jsm", certUtils); + return certUtils; +}); + +var gRDF = Cc["@mozilla.org/rdf/rdf-service;1"]. + getService(Ci.nsIRDFService); + +Cu.import("resource://gre/modules/Log.jsm"); +const LOGGER_ID = "addons.update-checker"; + +// Create a new logger for use by the Addons Update Checker +// (Requires AddonManager.jsm) +var logger = Log.repository.getLogger(LOGGER_ID); + +/** + * A serialisation method for RDF data that produces an identical string + * for matching RDF graphs. + * The serialisation is not complete, only assertions stemming from a given + * resource are included, multiple references to the same resource are not + * permitted, and the RDF prolog and epilog are not included. + * RDF Blob and Date literals are not supported. + */ +function RDFSerializer() { + this.cUtils = Cc["@mozilla.org/rdf/container-utils;1"]. + getService(Ci.nsIRDFContainerUtils); + this.resources = []; +} + +RDFSerializer.prototype = { + INDENT: " ", // The indent used for pretty-printing + resources: null, // Array of the resources that have been found + + /** + * Escapes characters from a string that should not appear in XML. + * + * @param aString + * The string to be escaped + * @return a string with all characters invalid in XML character data + * converted to entity references. + */ + escapeEntities: function(aString) { + aString = aString.replace(/&/g, "&"); + aString = aString.replace(//g, ">"); + return aString.replace(/"/g, """); + }, + + /** + * Serializes all the elements of an RDF container. + * + * @param aDs + * The RDF datasource + * @param aContainer + * The RDF container to output the child elements of + * @param aIndent + * The current level of indent for pretty-printing + * @return a string containing the serialized elements. + */ + serializeContainerItems: function(aDs, aContainer, aIndent) { + var result = ""; + var items = aContainer.GetElements(); + while (items.hasMoreElements()) { + var item = items.getNext().QueryInterface(Ci.nsIRDFResource); + result += aIndent + "\n" + result += this.serializeResource(aDs, item, aIndent + this.INDENT); + result += aIndent + "\n" + } + return result; + }, + + /** + * Serializes all em:* (see EM_NS) properties of an RDF resource except for + * the em:signature property. As this serialization is to be compared against + * the manifest signature it cannot contain the em:signature property itself. + * + * @param aDs + * The RDF datasource + * @param aResource + * The RDF resource that contains the properties to serialize + * @param aIndent + * The current level of indent for pretty-printing + * @return a string containing the serialized properties. + * @throws if the resource contains a property that cannot be serialized + */ + serializeResourceProperties: function(aDs, aResource, aIndent) { + var result = ""; + var items = []; + var arcs = aDs.ArcLabelsOut(aResource); + while (arcs.hasMoreElements()) { + var arc = arcs.getNext().QueryInterface(Ci.nsIRDFResource); + if (arc.ValueUTF8.substring(0, PREFIX_NS_EM.length) != PREFIX_NS_EM) + continue; + var prop = arc.ValueUTF8.substring(PREFIX_NS_EM.length); + if (prop == "signature") + continue; + + var targets = aDs.GetTargets(aResource, arc, true); + while (targets.hasMoreElements()) { + var target = targets.getNext(); + if (target instanceof Ci.nsIRDFResource) { + var item = aIndent + "\n"; + item += this.serializeResource(aDs, target, aIndent + this.INDENT); + item += aIndent + "\n"; + items.push(item); + } + else if (target instanceof Ci.nsIRDFLiteral) { + items.push(aIndent + "" + + this.escapeEntities(target.Value) + "\n"); + } + else if (target instanceof Ci.nsIRDFInt) { + items.push(aIndent + "" + + target.Value + "\n"); + } + else { + throw Components.Exception("Cannot serialize unknown literal type"); + } + } + } + items.sort(); + result += items.join(""); + return result; + }, + + /** + * Recursively serializes an RDF resource and all resources it links to. + * This will only output EM_NS properties and will ignore any em:signature + * property. + * + * @param aDs + * The RDF datasource + * @param aResource + * The RDF resource to serialize + * @param aIndent + * The current level of indent for pretty-printing. If undefined no + * indent will be added + * @return a string containing the serialized resource. + * @throws if the RDF data contains multiple references to the same resource. + */ + serializeResource: function(aDs, aResource, aIndent) { + if (this.resources.indexOf(aResource) != -1 ) { + // We cannot output multiple references to the same resource. + throw Components.Exception("Cannot serialize multiple references to " + aResource.Value); + } + if (aIndent === undefined) + aIndent = ""; + + this.resources.push(aResource); + var container = null; + var type = "Description"; + if (this.cUtils.IsSeq(aDs, aResource)) { + type = "Seq"; + container = this.cUtils.MakeSeq(aDs, aResource); + } + else if (this.cUtils.IsAlt(aDs, aResource)) { + type = "Alt"; + container = this.cUtils.MakeAlt(aDs, aResource); + } + else if (this.cUtils.IsBag(aDs, aResource)) { + type = "Bag"; + container = this.cUtils.MakeBag(aDs, aResource); + } + + var result = aIndent + "\n"; + return result; + } +} + +/** + * Sanitizes the update URL in an update item, as returned by + * parseRDFManifest and parseJSONManifest. Ensures that: + * + * - The URL is secure, or secured by a strong enough hash. + * - The security principal of the update manifest has permission to + * load the URL. + * + * @param aUpdate + * The update item to sanitize. + * @param aRequest + * The XMLHttpRequest used to load the manifest. + * @param aHashPattern + * The regular expression used to validate the update hash. + * @param aHashString + * The human-readable string specifying which hash functions + * are accepted. + */ +function sanitizeUpdateURL(aUpdate, aRequest, aHashPattern, aHashString) { + if (aUpdate.updateURL) { + let scriptSecurity = Services.scriptSecurityManager; + let principal = scriptSecurity.getChannelURIPrincipal(aRequest.channel); + try { + // This logs an error on failure, so no need to log it a second time + scriptSecurity.checkLoadURIStrWithPrincipal(principal, aUpdate.updateURL, + scriptSecurity.DISALLOW_SCRIPT); + } catch (e) { + delete aUpdate.updateURL; + return; + } + + if (AddonManager.checkUpdateSecurity && + !aUpdate.updateURL.startsWith("https:") && + !aHashPattern.test(aUpdate.updateHash)) { + logger.warn(`Update link ${aUpdate.updateURL} is not secure and is not verified ` + + `by a strong enough hash (needs to be ${aHashString}).`); + delete aUpdate.updateURL; + delete aUpdate.updateHash; + } + } +} + +/** + * Parses an RDF style update manifest into an array of update objects. + * + * @param aId + * The ID of the add-on being checked for updates + * @param aUpdateKey + * An optional update key for the add-on + * @param aRequest + * The XMLHttpRequest that has retrieved the update manifest + * @param aManifestData + * The pre-parsed manifest, as a bare XML DOM document + * @return an array of update objects + * @throws if the update manifest is invalid in any way + */ +function parseRDFManifest(aId, aUpdateKey, aRequest, aManifestData) { + if (aManifestData.documentElement.namespaceURI != PREFIX_NS_RDF) { + throw Components.Exception("Update manifest had an unrecognised namespace: " + + aManifestData.documentElement.namespaceURI); + } + + function EM_R(aProp) { + return gRDF.GetResource(PREFIX_NS_EM + aProp); + } + + function getValue(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; + } + + function getProperty(aDs, aSource, aProperty) { + return getValue(aDs.GetTarget(aSource, EM_R(aProperty), true)); + } + + function getBooleanProperty(aDs, aSource, aProperty) { + let propValue = aDs.GetTarget(aSource, EM_R(aProperty), true); + if (!propValue) + return undefined; + return getValue(propValue) == "true"; + } + + function getRequiredProperty(aDs, aSource, aProperty) { + let value = getProperty(aDs, aSource, aProperty); + if (!value) + throw Components.Exception("Update manifest is missing a required " + aProperty + " property."); + return value; + } + + 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); + rdfParser.parseString(ds, aRequest.channel.URI, aRequest.responseText); + + // Differentiating between add-on types is deprecated + let extensionRes = gRDF.GetResource(PREFIX_EXTENSION + aId); + let themeRes = gRDF.GetResource(PREFIX_THEME + aId); + let itemRes = gRDF.GetResource(PREFIX_ITEM + aId); + let addonRes; + if (ds.ArcLabelsOut(extensionRes).hasMoreElements()) + addonRes = extensionRes; + else if (ds.ArcLabelsOut(themeRes).hasMoreElements()) + addonRes = themeRes; + else + addonRes = itemRes; + + // If we have an update key then the update manifest must be signed + if (aUpdateKey) { + let signature = getProperty(ds, addonRes, "signature"); + if (!signature) + throw Components.Exception("Update manifest for " + aId + " does not contain a required signature"); + let serializer = new RDFSerializer(); + let updateString = null; + + try { + updateString = serializer.serializeResource(ds, addonRes); + } + catch (e) { + throw Components.Exception("Failed to generate signed string for " + aId + ". Serializer threw " + e, + e.result); + } + + let result = false; + + try { + let verifier = Cc["@mozilla.org/security/datasignatureverifier;1"]. + getService(Ci.nsIDataSignatureVerifier); + result = verifier.verifyData(updateString, signature, aUpdateKey); + } + catch (e) { + throw Components.Exception("The signature or updateKey for " + aId + " is malformed." + + "Verifier threw " + e, e.result); + } + + if (!result) + throw Components.Exception("The signature for " + aId + " was not created by the add-on's updateKey"); + } + + let updates = ds.GetTarget(addonRes, EM_R("updates"), true); + + // A missing updates property doesn't count as a failure, just as no avialable + // update information + if (!updates) { + logger.warn("Update manifest for " + aId + " did not contain an updates property"); + return []; + } + + if (!(updates instanceof Ci.nsIRDFResource)) + throw Components.Exception("Missing updates property for " + addonRes.Value); + + let cu = Cc["@mozilla.org/rdf/container-utils;1"]. + getService(Ci.nsIRDFContainerUtils); + if (!cu.IsContainer(ds, updates)) + throw Components.Exception("Updates property was not an RDF container"); + + let results = []; + let ctr = Cc["@mozilla.org/rdf/container;1"]. + createInstance(Ci.nsIRDFContainer); + ctr.Init(ds, updates); + let items = ctr.GetElements(); + while (items.hasMoreElements()) { + let item = items.getNext().QueryInterface(Ci.nsIRDFResource); + let version = getProperty(ds, item, "version"); + if (!version) { + logger.warn("Update manifest is missing a required version property."); + continue; + } + + logger.debug("Found an update entry for " + aId + " version " + version); + + let targetApps = ds.GetTargets(item, EM_R("targetApplication"), true); + while (targetApps.hasMoreElements()) { + let targetApp = targetApps.getNext().QueryInterface(Ci.nsIRDFResource); + + let appEntry = {}; + try { + appEntry.id = getRequiredProperty(ds, targetApp, "id"); + appEntry.minVersion = getRequiredProperty(ds, targetApp, "minVersion"); + appEntry.maxVersion = getRequiredProperty(ds, targetApp, "maxVersion"); + } + catch (e) { + logger.warn(e); + continue; + } + + let result = { + id: aId, + version: version, + multiprocessCompatible: getBooleanProperty(ds, item, "multiprocessCompatible"), + updateURL: getProperty(ds, targetApp, "updateLink"), + updateHash: getProperty(ds, targetApp, "updateHash"), + updateInfoURL: getProperty(ds, targetApp, "updateInfoURL"), + strictCompatibility: !!getBooleanProperty(ds, targetApp, "strictCompatibility"), + targetApplications: [appEntry] + }; + + // The JSON update protocol requires an SHA-2 hash. RDF still + // supports SHA-1, for compatibility reasons. + sanitizeUpdateURL(result, aRequest, /^sha/, "sha1 or stronger"); + + results.push(result); + } + } + return results; +} + +/** + * Parses an JSON update manifest into an array of update objects. + * + * @param aId + * The ID of the add-on being checked for updates + * @param aUpdateKey + * An optional update key for the add-on + * @param aRequest + * The XMLHttpRequest that has retrieved the update manifest + * @param aManifestData + * The pre-parsed manifest, as a JSON object tree + * @return an array of update objects + * @throws if the update manifest is invalid in any way + */ +function parseJSONManifest(aId, aUpdateKey, aRequest, aManifestData) { + if (aUpdateKey) + throw Components.Exception("Update keys are not supported for JSON update manifests"); + + let TYPE_CHECK = { + "array": val => Array.isArray(val), + "object": val => val && typeof val == "object" && !Array.isArray(val), + }; + + function getProperty(aObj, aProperty, aType, aDefault = undefined) { + if (!(aProperty in aObj)) + return aDefault; + + let value = aObj[aProperty]; + + let matchesType = aType in TYPE_CHECK ? TYPE_CHECK[aType](value) : typeof value == aType; + if (!matchesType) + throw Components.Exception(`Update manifest property '${aProperty}' has incorrect type (expected ${aType})`); + + return value; + } + + function getRequiredProperty(aObj, aProperty, aType) { + let value = getProperty(aObj, aProperty, aType); + if (value === undefined) + throw Components.Exception(`Update manifest is missing a required ${aProperty} property.`); + return value; + } + + let manifest = aManifestData; + + if (!TYPE_CHECK["object"](manifest)) + throw Components.Exception("Root element of update manifest must be a JSON object literal"); + + // The set of add-ons this manifest has updates for + let addons = getRequiredProperty(manifest, "addons", "object"); + + // The entry for this particular add-on + let addon = getProperty(addons, aId, "object"); + + // A missing entry doesn't count as a failure, just as no avialable update + // information + if (!addon) { + logger.warn("Update manifest did not contain an entry for " + aId); + return []; + } + + // The list of available updates + let updates = getProperty(addon, "updates", "array", []); + + let results = []; + + for (let update of updates) { + let version = getRequiredProperty(update, "version", "string"); + + logger.debug(`Found an update entry for ${aId} version ${version}`); + + let applications = getProperty(update, "applications", "object", + { gecko: {} }); + + // "gecko" is currently the only supported application entry. If + // it's missing, skip this update. + if (!("gecko" in applications)) { + logger.debug("gecko not in application entry, skipping update of ${addon}") + continue; + } + + let app = getProperty(applications, "gecko", "object"); + + let appEntry = { + id: TOOLKIT_ID, + minVersion: getProperty(app, "strict_min_version", "string", + AddonManagerPrivate.webExtensionsMinPlatformVersion), + maxVersion: "*", + }; + + let result = { + id: aId, + version: version, + multiprocessCompatible: getProperty(update, "multiprocess_compatible", "boolean", true), + updateURL: getProperty(update, "update_link", "string"), + updateHash: getProperty(update, "update_hash", "string"), + updateInfoURL: getProperty(update, "update_info_url", "string"), + strictCompatibility: false, + targetApplications: [appEntry], + }; + + if ("strict_max_version" in app) { + if ("advisory_max_version" in app) { + logger.warn("Ignoring 'advisory_max_version' update manifest property for " + + aId + " property since 'strict_max_version' also present"); + } + + appEntry.maxVersion = getProperty(app, "strict_max_version", "string"); + result.strictCompatibility = appEntry.maxVersion != "*"; + } else if ("advisory_max_version" in app) { + appEntry.maxVersion = getProperty(app, "advisory_max_version", "string"); + } + + // The JSON update protocol requires an SHA-2 hash. RDF still + // supports SHA-1, for compatibility reasons. + sanitizeUpdateURL(result, aRequest, /^sha(256|512):/, "sha256 or sha512"); + + results.push(result); + } + return results; +} + +/** + * Starts downloading an update manifest and then passes it to an appropriate + * parser to convert to an array of update objects + * + * @param aId + * The ID of the add-on being checked for updates + * @param aUpdateKey + * An optional update key for the add-on + * @param aUrl + * The URL of the update manifest + * @param aObserver + * An observer to pass results to + */ +function UpdateParser(aId, aUpdateKey, aUrl, aObserver) { + this.id = aId; + this.updateKey = aUpdateKey; + this.observer = aObserver; + this.url = aUrl; + + let requireBuiltIn = true; + try { + requireBuiltIn = Services.prefs.getBoolPref(PREF_UPDATE_REQUIREBUILTINCERTS); + } + catch (e) { + } + + logger.debug("Requesting " + aUrl); + try { + this.request = new ServiceRequest(); + this.request.open("GET", this.url, true); + this.request.channel.notificationCallbacks = new CertUtils.BadCertHandler(!requireBuiltIn); + this.request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE; + // Prevent the request from writing to cache. + this.request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING; + this.request.overrideMimeType("text/plain"); + this.request.setRequestHeader("Moz-XPI-Update", "1", true); + this.request.timeout = TIMEOUT; + this.request.addEventListener("load", () => this.onLoad(), false); + this.request.addEventListener("error", () => this.onError(), false); + this.request.addEventListener("timeout", () => this.onTimeout(), false); + this.request.send(null); + } + catch (e) { + logger.error("Failed to request update manifest", e); + } +} + +UpdateParser.prototype = { + id: null, + updateKey: null, + observer: null, + request: null, + url: null, + + /** + * Called when the manifest has been successfully loaded. + */ + onLoad: function() { + let request = this.request; + this.request = null; + this._doneAt = new Error("place holder"); + + let requireBuiltIn = true; + try { + requireBuiltIn = Services.prefs.getBoolPref(PREF_UPDATE_REQUIREBUILTINCERTS); + } + catch (e) { + } + + try { + CertUtils.checkCert(request.channel, !requireBuiltIn); + } + catch (e) { + logger.warn("Request failed: " + this.url + " - " + e); + this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR); + return; + } + + if (!Components.isSuccessCode(request.status)) { + logger.warn("Request failed: " + this.url + " - " + request.status); + this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR); + return; + } + + let channel = request.channel; + if (channel instanceof Ci.nsIHttpChannel && !channel.requestSucceeded) { + logger.warn("Request failed: " + this.url + " - " + channel.responseStatus + + ": " + channel.responseStatusText); + this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR); + return; + } + + // Detect the manifest type by first attempting to parse it as + // JSON, and falling back to parsing it as XML if that fails. + let parser; + try { + try { + let json = JSON.parse(request.responseText); + + parser = () => parseJSONManifest(this.id, this.updateKey, request, json); + } catch (e) { + if (!(e instanceof SyntaxError)) + throw e; + let domParser = Cc["@mozilla.org/xmlextras/domparser;1"].createInstance(Ci.nsIDOMParser); + let xml = domParser.parseFromString(request.responseText, "text/xml"); + + if (xml.documentElement.namespaceURI == XMLURI_PARSE_ERROR) + throw new Error("Update manifest was not valid XML or JSON"); + + parser = () => parseRDFManifest(this.id, this.updateKey, request, xml); + } + } catch (e) { + logger.warn("onUpdateCheckComplete failed to determine manifest type"); + this.notifyError(AddonUpdateChecker.ERROR_UNKNOWN_FORMAT); + return; + } + + let results; + try { + results = parser(); + } + catch (e) { + logger.warn("onUpdateCheckComplete failed to parse update manifest", e); + this.notifyError(AddonUpdateChecker.ERROR_PARSE_ERROR); + return; + } + + if ("onUpdateCheckComplete" in this.observer) { + try { + this.observer.onUpdateCheckComplete(results); + } + catch (e) { + logger.warn("onUpdateCheckComplete notification failed", e); + } + } + else { + logger.warn("onUpdateCheckComplete may not properly cancel", new Error("stack marker")); + } + }, + + /** + * Called when the request times out + */ + onTimeout: function() { + this.request = null; + this._doneAt = new Error("Timed out"); + logger.warn("Request for " + this.url + " timed out"); + this.notifyError(AddonUpdateChecker.ERROR_TIMEOUT); + }, + + /** + * Called when the manifest failed to load. + */ + onError: function() { + if (!Components.isSuccessCode(this.request.status)) { + logger.warn("Request failed: " + this.url + " - " + this.request.status); + } + else if (this.request.channel instanceof Ci.nsIHttpChannel) { + try { + if (this.request.channel.requestSucceeded) { + logger.warn("Request failed: " + this.url + " - " + + this.request.channel.responseStatus + ": " + + this.request.channel.responseStatusText); + } + } + catch (e) { + logger.warn("HTTP Request failed for an unknown reason"); + } + } + else { + logger.warn("Request failed for an unknown reason"); + } + + this.request = null; + this._doneAt = new Error("UP_onError"); + + this.notifyError(AddonUpdateChecker.ERROR_DOWNLOAD_ERROR); + }, + + /** + * Helper method to notify the observer that an error occured. + */ + notifyError: function(aStatus) { + if ("onUpdateCheckError" in this.observer) { + try { + this.observer.onUpdateCheckError(aStatus); + } + catch (e) { + logger.warn("onUpdateCheckError notification failed", e); + } + } + }, + + /** + * Called to cancel an in-progress update check. + */ + cancel: function() { + if (!this.request) { + logger.error("Trying to cancel already-complete request", this._doneAt); + return; + } + this.request.abort(); + this.request = null; + this._doneAt = new Error("UP_cancel"); + this.notifyError(AddonUpdateChecker.ERROR_CANCELLED); + } +}; + +/** + * Tests if an update matches a version of the application or platform + * + * @param aUpdate + * The available update + * @param aAppVersion + * The application version to use + * @param aPlatformVersion + * The platform version to use + * @param aIgnoreMaxVersion + * Ignore maxVersion when testing if an update matches. Optional. + * @param aIgnoreStrictCompat + * Ignore strictCompatibility when testing if an update matches. Optional. + * @param aCompatOverrides + * AddonCompatibilityOverride objects to match against. Optional. + * @return true if the update is compatible with the application/platform + */ +function matchesVersions(aUpdate, aAppVersion, aPlatformVersion, + aIgnoreMaxVersion, aIgnoreStrictCompat, + aCompatOverrides) { + if (aCompatOverrides) { + let override = AddonRepository.findMatchingCompatOverride(aUpdate.version, + aCompatOverrides, + aAppVersion, + aPlatformVersion); + if (override && override.type == "incompatible") + return false; + } + + if (aUpdate.strictCompatibility && !aIgnoreStrictCompat) + aIgnoreMaxVersion = false; + + let result = false; + for (let app of aUpdate.targetApplications) { + if (app.id == Services.appinfo.ID) { + return (Services.vc.compare(aAppVersion, app.minVersion) >= 0) && + (aIgnoreMaxVersion || (Services.vc.compare(aAppVersion, app.maxVersion) <= 0)); + } + if (app.id == TOOLKIT_ID) { + result = (Services.vc.compare(aPlatformVersion, app.minVersion) >= 0) && + (aIgnoreMaxVersion || (Services.vc.compare(aPlatformVersion, app.maxVersion) <= 0)); + } + } + return result; +} + +this.AddonUpdateChecker = { + // These must be kept in sync with AddonManager + // The update check timed out + ERROR_TIMEOUT: -1, + // There was an error while downloading the update information. + ERROR_DOWNLOAD_ERROR: -2, + // The update information was malformed in some way. + ERROR_PARSE_ERROR: -3, + // The update information was not in any known format. + ERROR_UNKNOWN_FORMAT: -4, + // The update information was not correctly signed or there was an SSL error. + ERROR_SECURITY_ERROR: -5, + // The update was cancelled + ERROR_CANCELLED: -6, + + /** + * Retrieves the best matching compatibility update for the application from + * a list of available update objects. + * + * @param aUpdates + * An array of update objects + * @param aVersion + * The version of the add-on to get new compatibility information for + * @param aIgnoreCompatibility + * An optional parameter to get the first compatibility update that + * is compatible with any version of the application or toolkit + * @param aAppVersion + * The version of the application or null to use the current version + * @param aPlatformVersion + * The version of the platform or null to use the current version + * @param aIgnoreMaxVersion + * Ignore maxVersion when testing if an update matches. Optional. + * @param aIgnoreStrictCompat + * Ignore strictCompatibility when testing if an update matches. Optional. + * @return an update object if one matches or null if not + */ + getCompatibilityUpdate: function(aUpdates, aVersion, aIgnoreCompatibility, + aAppVersion, aPlatformVersion, + aIgnoreMaxVersion, aIgnoreStrictCompat) { + if (!aAppVersion) + aAppVersion = Services.appinfo.version; + if (!aPlatformVersion) + aPlatformVersion = Services.appinfo.platformVersion; + + for (let update of aUpdates) { + if (Services.vc.compare(update.version, aVersion) == 0) { + if (aIgnoreCompatibility) { + for (let targetApp of update.targetApplications) { + let id = targetApp.id; + if (id == Services.appinfo.ID || id == TOOLKIT_ID) + return update; + } + } + else if (matchesVersions(update, aAppVersion, aPlatformVersion, + aIgnoreMaxVersion, aIgnoreStrictCompat)) { + return update; + } + } + } + return null; + }, + + /** + * Returns the newest available update from a list of update objects. + * + * @param aUpdates + * An array of update objects + * @param aAppVersion + * The version of the application or null to use the current version + * @param aPlatformVersion + * The version of the platform or null to use the current version + * @param aIgnoreMaxVersion + * When determining compatible updates, ignore maxVersion. Optional. + * @param aIgnoreStrictCompat + * When determining compatible updates, ignore strictCompatibility. Optional. + * @param aCompatOverrides + * Array of AddonCompatibilityOverride to take into account. Optional. + * @return an update object if one matches or null if not + */ + getNewestCompatibleUpdate: function(aUpdates, aAppVersion, aPlatformVersion, + aIgnoreMaxVersion, aIgnoreStrictCompat, + aCompatOverrides) { + if (!aAppVersion) + aAppVersion = Services.appinfo.version; + if (!aPlatformVersion) + aPlatformVersion = Services.appinfo.platformVersion; + + let blocklist = Cc["@mozilla.org/extensions/blocklist;1"]. + getService(Ci.nsIBlocklistService); + + let newest = null; + for (let update of aUpdates) { + if (!update.updateURL) + continue; + let state = blocklist.getAddonBlocklistState(update, aAppVersion, aPlatformVersion); + if (state != Ci.nsIBlocklistService.STATE_NOT_BLOCKED) + continue; + if ((newest == null || (Services.vc.compare(newest.version, update.version) < 0)) && + matchesVersions(update, aAppVersion, aPlatformVersion, + aIgnoreMaxVersion, aIgnoreStrictCompat, + aCompatOverrides)) { + newest = update; + } + } + return newest; + }, + + /** + * Starts an update check. + * + * @param aId + * The ID of the add-on being checked for updates + * @param aUpdateKey + * An optional update key for the add-on + * @param aUrl + * The URL of the add-on's update manifest + * @param aObserver + * An observer to notify of results + * @return UpdateParser so that the caller can use UpdateParser.cancel() to shut + * down in-progress update requests + */ + checkForUpdates: function(aId, aUpdateKey, aUrl, aObserver) { + return new UpdateParser(aId, aUpdateKey, aUrl, aObserver); + } +}; diff --git a/toolkit/mozapps/extensions/internal/Content.js b/toolkit/mozapps/extensions/internal/Content.js new file mode 100644 index 0000000000..9f366ba327 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/Content.js @@ -0,0 +1,38 @@ +/* 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/. */ + +/* globals addMessageListener*/ + +"use strict"; + +(function() { + +var {classes: Cc, interfaces: Ci, utils: Cu} = Components; + +var {Services} = Cu.import("resource://gre/modules/Services.jsm", {}); + +var nsIFile = Components.Constructor("@mozilla.org/file/local;1", "nsIFile", + "initWithPath"); + +const MSG_JAR_FLUSH = "AddonJarFlush"; +const MSG_MESSAGE_MANAGER_CACHES_FLUSH = "AddonMessageManagerCachesFlush"; + + +try { + if (Services.appinfo.processType !== Services.appinfo.PROCESS_TYPE_DEFAULT) { + // Propagate JAR cache flush notifications across process boundaries. + addMessageListener(MSG_JAR_FLUSH, function(message) { + let file = new nsIFile(message.data); + Services.obs.notifyObservers(file, "flush-cache-entry", null); + }); + // Propagate message manager caches flush notifications across processes. + addMessageListener(MSG_MESSAGE_MANAGER_CACHES_FLUSH, function() { + Services.obs.notifyObservers(null, "message-manager-flush-caches", null); + }); + } +} catch (e) { + Cu.reportError(e); +} + +})(); diff --git a/toolkit/mozapps/extensions/internal/E10SAddonsRollout.jsm b/toolkit/mozapps/extensions/internal/E10SAddonsRollout.jsm new file mode 100644 index 0000000000..3bcee44d34 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/E10SAddonsRollout.jsm @@ -0,0 +1,982 @@ +/* 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"; + +this.EXPORTED_SYMBOLS = [ "isAddonPartOfE10SRollout" ]; + +const Cu = Components.utils; +Cu.import("resource://gre/modules/Preferences.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); + +const PREF_E10S_ADDON_BLOCKLIST = "extensions.e10s.rollout.blocklist"; +const PREF_E10S_ADDON_POLICY = "extensions.e10s.rollout.policy"; + +const ADDONS = { + "Greasemonkey": { // Greasemonkey + id: "{e4a8a97b-f2ed-450b-b12d-ee082ba24781}", minVersion: "3.8", + }, + + "DYTV": { // Download YouTube Videos as MP4 + id: "{b9bfaf1c-a63f-47cd-8b9a-29526ced9060}", minVersion: "1.8.7", + }, + + "VDH": { // Video Download Helper + id: "{b9db16a4-6edc-47ec-a1f4-b86292ed211d}", minVersion: "5.6.1", + }, + + "Lightbeam": { // Lightbeam + id: "jid1-F9UJ2thwoAm5gQ@jetpack", minVersion: "1.3.0.1", + }, + + "ABP": { // Adblock Plus + id: "{d10d0bf8-f5b5-c8b4-a8b2-2b9879e08c5d}", minVersion: "2.7.3", + }, + + "uBlockOrigin": { // uBlock Origin + id: "uBlock0@raymondhill.net", minVersion: "1.7.6", + }, + + "Emoji": { // Emoji Cheatsheet + id: "jid1-Xo5SuA6qc1DFpw@jetpack", minVersion: "1.1.1", + }, + + "ASP": { // Awesome Screenshot Plus + id: "jid0-GXjLLfbCoAx0LcltEdFrEkQdQPI@jetpack", minVersion: "3.0.10", + }, + + "PersonasPlus": { // PersonasPlus + id: "personas@christopher.beard", minVersion: "1.8.0", + }, + + "ACR": { // Add-on Compatibility Reporter + id: "compatibility@addons.mozilla.org", minVersion: "2.2.0", + }, + + // Add-ons used for testing + "test1": { + id: "bootstrap1@tests.mozilla.org", minVersion: "1.0", + }, + + "test2": { + id: "bootstrap2@tests.mozilla.org", minVersion: "1.0", + }, +}; + +// NOTE: Do not modify sets or policies after they have already been +// published to users. They must remain unchanged to provide valid data. + +// Set 2 used during 48 Beta cycle. Kept here for historical reasons. +const set2 = [ADDONS.Greasemonkey, + ADDONS.DYTV, + ADDONS.VDH, + ADDONS.Lightbeam, + ADDONS.ABP, + ADDONS.uBlockOrigin, + ADDONS.Emoji, + ADDONS.ASP, + ADDONS.PersonasPlus]; + +const set49Release = [ + ADDONS.Greasemonkey, + ADDONS.DYTV, + ADDONS.VDH, + ADDONS.Lightbeam, + ADDONS.ABP, + ADDONS.uBlockOrigin, + ADDONS.Emoji, + ADDONS.ASP, + ADDONS.PersonasPlus, + ADDONS.ACR +]; + +// These are only the add-ons in the Add-Ons Manager Discovery +// pane. This set is here in case we need to reduce add-ons +// exposure live on Release. +const set49PaneOnly = [ + ADDONS.ABP, + ADDONS.VDH, + ADDONS.Emoji, + ADDONS.ASP, + ADDONS.ACR +] + +// ================== ADDONS FOR 51 RELEASE ================== +// +// During the 51 beta cycle, we tested e10s with all addons +// except those explicitly marked as being incompatible. +// For release, instead of opening this up, we assembled +// the lists below with all addons that were seen on beta +// and had over 50 installs. +// +// This list is in a new format to allow fast access and also +// to allow controlling by the number of addons installed. + +const set51Release = { + "_65Members_@download.fromdoctopdf.com": {minVersion: "7.102.10.4221", installs: 32092}, + "light_plugin_ACF0E80077C511E59DED005056C00008@kaspersky.com": {minVersion: "4.6.3-15", installs: 27758}, + "_ceMembers_@free.easypdfcombine.com": {minVersion: "7.102.10.4117", installs: 17797}, + "caa1-aDOiCAxFFMOVIX@jetpack": {minVersion: "0.1.7", installs: 13150}, + "{4ED1F68A-5463-4931-9384-8FFF5ED91D92}": {minVersion: "5.0.248.0", installs: 12774}, + "_dbMembers_@free.getformsonline.com": {minVersion: "7.102.10.4251", installs: 11909}, + "_4zMembers_@www.videodownloadconverter.com": {minVersion: "7.102.10.5033", installs: 11612}, + "light_plugin_F6F079488B53499DB99380A7E11A93F6@kaspersky.com": {minVersion: "5.0.141-4-20161031140250", installs: 10944}, + "YoutubeDownloader@PeterOlayev.com": {minVersion: "2.4.1", installs: 10722}, + "{82AF8DCA-6DE9-405D-BD5E-43525BDAD38A}": {minVersion: "8.0.0.9103", installs: 8856}, + "client@anonymox.net": {minVersion: "2.5.2", installs: 8225}, + "_8hMembers_@download.allin1convert.com": {minVersion: "7.102.10.3584", installs: 7681}, + "light_plugin_D772DC8D6FAF43A29B25C4EBAA5AD1DE@kaspersky.com": {minVersion: "4.6.2-42-20160922074409", installs: 7177}, + "_dzMembers_@www.pconverter.com": {minVersion: "7.102.10.4851", installs: 7115}, + "fxdevtools-adapters@mozilla.org": {minVersion: "0.3.5", installs: 6926}, + "_9pMembers_@free.onlinemapfinder.com": {minVersion: "7.102.10.4836", installs: 6583}, + "@DownloadManager": {minVersion: "0.2.1", installs: 6412}, + "ar1er-ewrgfdgomusix@jetpack": {minVersion: "1.0.6", installs: 5975}, + "_agMembers_@free.premierdownloadmanager.com": {minVersion: "7.102.10.4846", installs: 5605}, + "_paMembers_@www.filmfanatic.com": {minVersion: "7.102.10.4163", installs: 5448}, + "_gtMembers_@free.gamingwonderland.com": {minVersion: "7.102.10.4263", installs: 5241}, + "LVD-SAE@iacsearchandmedia.com": {minVersion: "8.5", installs: 4694}, + "_fsMembers_@free.pdfconverterhq.com": {minVersion: "7.102.10.4849", installs: 4526}, + "_6xMembers_@www.readingfanatic.com": {minVersion: "7.102.10.4914", installs: 4417}, + "@mysmartprice-ff": {minVersion: "0.0.6", installs: 4381}, + "jid1-YcMV6ngYmQRA2w@jetpack": {minVersion: "1.37.9", installs: 3899}, + "{58d735b4-9d6c-4e37-b146-7b9f7e79e318}": {minVersion: "1.6", installs: 3733}, + "anttoolbar@ant.com": {minVersion: "2.4.7.47", installs: 3720}, + "adblockpopups@jessehakanen.net": {minVersion: "0.9.2.1-signed.1-signed", installs: 3602}, + "ERAIL.IN.FFPLUGIN@jetpack": {minVersion: "6.0.rev142", installs: 3545}, + "WebProtection@360safe.com": {minVersion: "5.0.0.1005", installs: 3475}, + "yasearch@yandex.ru": {minVersion: "8.20.4", installs: 3299}, + "{19503e42-ca3c-4c27-b1e2-9cdb2170ee34}": {minVersion: "1.5.6.14", installs: 3106}, + "{C1A2A613-35F1-4FCF-B27F-2840527B6556}": {minVersion: "2016.8.1.9", installs: 3083}, + "_b7Members_@free.mytransitguide.com": {minVersion: "7.102.10.4812", installs: 3011}, + "_9tMembers_@free.internetspeedtracker.com": {minVersion: "7.102.10.4339", installs: 2828}, + "_64Members_@www.televisionfanatic.com": {minVersion: "7.102.10.4968", installs: 2821}, + "info@youtube-mp3.org": {minVersion: "1.0.9.1-signed.1-signed", installs: 2717}, + "ffext_basicvideoext@startpage24": {minVersion: "1.97.37.1-signed.1-signed", installs: 2663}, + "MUB-SAE@iacsearchandmedia.com": {minVersion: "8.7", installs: 2650}, + "_4jMembers_@www.radiorage.com": {minVersion: "7.102.10.4916", installs: 2631}, + "@Email": {minVersion: "4.0.12", installs: 2583}, + "_gcMembers_@www.weatherblink.com": {minVersion: "7.38.8.56523", installs: 2519}, + "_dqMembers_@www.downspeedtest.com": {minVersion: "7.102.10.3827", installs: 2445}, + "translator@zoli.bod": {minVersion: "2.1.0.5.1.1-signed", installs: 2310}, + "{a38384b3-2d1d-4f36-bc22-0f7ae402bcd7}": {minVersion: "1.0.0.51", installs: 2190}, + "_1eMembers_@www.videoscavenger.com": {minVersion: "7.38.8.45273", installs: 2185}, + "tvplusnewtab-the-extension1@mozilla.com": {minVersion: "0.1.5", installs: 2155}, + "homepage@mail.ru": {minVersion: "1.0.2", installs: 2124}, + "search@mail.ru": {minVersion: "1.0.7", installs: 2038}, + "_69Members_@www.packagetracer.com": {minVersion: "7.102.10.4831", installs: 2036}, + "{7b8a500a-a464-4624-bd4f-73eaafe0f766}": {minVersion: "3", installs: 2027}, + "paulsaintuzb@gmail.com": {minVersion: "8.2.1", installs: 2005}, + "k7srff_enUS@k7computing.com": {minVersion: "2.4", installs: 1929}, + "_e5Members_@www.productivityboss.com": {minVersion: "7.38.8.46590", installs: 1892}, + "vdpure@link64": {minVersion: "1.97.43", installs: 1860}, + "_9tMembers_@download.internetspeedtracker.com": {minVersion: "7.38.8.56171", installs: 1824}, + "_g3Members_@free.easyphotoedit.com": {minVersion: "7.102.10.4108", installs: 1822}, + "_64Members_@download.televisionfanatic.com": {minVersion: "7.38.9.3004", installs: 1730}, + "_8iMembers_@download.audiotoaudio.com": {minVersion: "7.102.10.3585", installs: 1704}, + "adblockultimate@adblockultimate.net": {minVersion: "2.25", installs: 1648}, + "eagleget_ffext@eagleget.com": {minVersion: "3.8", installs: 1640}, + "_9eMembers_@free.findmefreebies.com": {minVersion: "7.102.10.4193", installs: 1638}, + "content_blocker_663BE8@kaspersky.com": {minVersion: "4.5.4.19.1", installs: 1625}, + "virtual_keyboard_074028@kaspersky.com": {minVersion: "4.5.4.19.1", installs: 1624}, + "browsec@browsec.com": {minVersion: "2.0.3", installs: 1610}, + "@Maps": {minVersion: "4.0.0", installs: 1587}, + "_exMembers_@free.easydocmerge.com": {minVersion: "7.102.10.4137", installs: 1493}, + "{635abd67-4fe9-1b23-4f01-e679fa7484c1}": {minVersion: "5.0.2", installs: 1490}, + "abb@amazon.com": {minVersion: "10.1612.1.304", installs: 1463}, + "{1BC9BA34-1EED-42ca-A505-6D2F1A935BBB}": {minVersion: "6.2.18.1", installs: 1436}, + "mp4downloader@jeff.net": {minVersion: "1.3.3.1-signed.1-signed", installs: 1410}, + "jid1-16aeif9OQIRKxA@jetpack": {minVersion: "1.1.4", installs: 1399}, + "{c45c406e-ab73-11d8-be73-000a95be3b12}": {minVersion: "1.2.11", installs: 1367}, + "online_banking_08806E@kaspersky.com": {minVersion: "4.5.4.19.1", installs: 1356}, + "_ewMembers_@free.mergedocsonline.com": {minVersion: "7.102.10.4710", installs: 1337}, + "@DiscreteSearch": {minVersion: "0.2.1", installs: 1306}, + "{6AC85730-7D0F-4de0-B3FA-21142DD85326}": {minVersion: "2.8.2", installs: 1286}, + "{063DA41A-2561-401B-91FA-AC75E460F4EB}": {minVersion: "1.0.7.1", installs: 1280}, + "netvideohunter@netvideohunter.com": {minVersion: "1.2", installs: 1260}, + "_8eMembers_@download.howtosimplified.com": {minVersion: "7.102.10.4285", installs: 1230}, + "FGZ-SAE@iacsearchandmedia.com": {minVersion: "8.5", installs: 1220}, + "adguardadblocker@adguard.com": {minVersion: "2.4.14", installs: 1172}, + "_39Members_@www.mapsgalaxy.com": {minVersion: "7.102.10.4730", installs: 1171}, + "_euMembers_@free.filesendsuite.com": {minVersion: "7.102.10.4154", installs: 1166}, + "_brMembers_@free.yourtemplatefinder.com": {minVersion: "7.102.10.5047", installs: 1159}, + "_8jMembers_@download.myimageconverter.com": {minVersion: "7.102.10.4778", installs: 1150}, + "_12Members_@free.myscrapnook.com": {minVersion: "7.102.10.4739", installs: 1113}, + "_7eMembers_@www.homeworksimplified.com": {minVersion: "7.102.10.4290", installs: 1109}, + "{fe272bd1-5f76-4ea4-8501-a05d35d823fc}": {minVersion: "2.1.9.1-signed.1-let-fixed.1-signed", installs: 1108}, + "_frMembers_@free.testforspeed.com": {minVersion: "7.102.10.4993", installs: 1107}, + "{068e178c-61a9-4a63-b74f-87404a6f5ea1}": {minVersion: "2", installs: 1104}, + "@Package": {minVersion: "0.2.0", installs: 1092}, + "6asa42dfa4784fsf368g@youtubeconverter.me": {minVersion: "0.1", installs: 1071}, + "_diMembers_@www.free.easymaillogin.com": {minVersion: "7.102.10.4112", installs: 1043}, + "_v4Members_@www.dictionaryboss.com": {minVersion: "7.102.10.3797", installs: 1035}, + "colorPicker@colorPicker": {minVersion: "3.0.1-signed.1-signed", installs: 1023}, + "hotspot-shield@anchorfree.com": {minVersion: "1.2.87", installs: 1000}, + "manishjain9@hotmail.com_easiestyoutube": {minVersion: "7.2.1-signed.1-let-fixed.1-signed", installs: 993}, + "{cd617375-6743-4ee8-bac4-fbf10f35729e}": {minVersion: "2.9.6", installs: 987}, + "@Converter": {minVersion: "4.1.0", installs: 986}, + "{dd3d7613-0246-469d-bc65-2a3cc1668adc}": {minVersion: "1.1.8.1-signed.1-signed", installs: 983}, + "ubufox@ubuntu.com": {minVersion: "3.2", installs: 950}, + "jid1-lpoiffmusixlib@jetpack": {minVersion: "0.1.9", installs: 945}, + "_5aMembers_@download.mywebface.com": {minVersion: "7.102.10.4837", installs: 930}, + "leethax@leethax.net": {minVersion: "2016.12.02", installs: 930}, + "{1A2D0EC4-75F5-4c91-89C4-3656F6E44B68}": {minVersion: "0.6.3.1-signed.1-signed", installs: 885}, + "{64161300-e22b-11db-8314-0800200c9a66}": {minVersion: "0.9.6.18", installs: 875}, + "_bfMembers_@free.snapmyscreen.com": {minVersion: "7.102.10.4951", installs: 827}, + "uriloader@pdf.js": {minVersion: "1.0.277.1-signed.1-signed", installs: 815}, + "{e968fc70-8f95-4ab9-9e79-304de2a71ee1}": {minVersion: "0.7.3.1-signed.1-signed", installs: 805}, + "save-as-pdf-ff@pdfcrowd.com": {minVersion: "1.5.1-signed.1-signed", installs: 804}, + "{75CEEE46-9B64-46f8-94BF-54012DE155F0}": {minVersion: "0.4.15", installs: 794}, + "safesearchplus2@avira.com": {minVersion: "1.4.1.371", installs: 786}, + "easyscreenshot@mozillaonline.com": {minVersion: "1.2.8", installs: 785}, + "_eeMembers_@download.freeradiocast.com": {minVersion: "7.38.8.46366", installs: 783}, + "_89Members_@download.safepcrepair.com": {minVersion: "7.39.8.51080", installs: 777}, + "{a3a5c777-f583-4fef-9380-ab4add1bc2a5}": {minVersion: "2.4.2.1-signed", installs: 771}, + "content_blocker@kaspersky.com": {minVersion: "4.0.10.15", installs: 770}, + "safesearch@avira.com": {minVersion: "1.4.1.371", installs: 767}, + "youtube2mp3@mondayx.de": {minVersion: "1.2.3.1-signed.1-signed", installs: 748}, + "2020Player_IKEA@2020Technologies.com": {minVersion: "5.0.94.1", installs: 736}, + "_edMembers_@free.myradioaccess.com": {minVersion: "7.102.10.4797", installs: 734}, + "_dmMembers_@free.gounzip.com": {minVersion: "7.102.10.4277", installs: 733}, + "Media-Newtab-the-extension1@mozilla.com": {minVersion: "0.1.6", installs: 732}, + "foxmarks@kei.com": {minVersion: "4.3.19", installs: 728}, + "{e8deb9e5-5688-4655-838a-b7a121a9f16e}": {minVersion: "48.4", installs: 726}, + "{195A3098-0BD5-4e90-AE22-BA1C540AFD1E}": {minVersion: "4.1.0.1-signed.1-signed", installs: 722}, + "jid1-4P0kohSJxU1qGg@jetpack": {minVersion: "1.22.550", installs: 719}, + "DailymotionVideoDownloader@PeterOlayev.com": {minVersion: "1.0.6.1-signed.1-signed", installs: 717}, + "jid1-P34HaABBBpOerQ@jetpack": {minVersion: "0.2.1-signed.1-signed", installs: 715}, + "SQLiteManager@mrinalkant.blogspot.com": {minVersion: "0.8.3.1-signed.1-signed", installs: 700}, + "2.0@disconnect.me": {minVersion: "3.15.3.1-signed.1-signed", installs: 693}, + "multifox@hultmann": {minVersion: "3.2.3", installs: 690}, + "_5mMembers_@download.myfuncards.com": {minVersion: "7.102.10.4783", installs: 679}, + "_btMembers_@free.catsandcatapults.com": {minVersion: "7.102.10.3677", installs: 673}, + "pavel.sherbakov@gmail.com": {minVersion: "19.1.1", installs: 666}, + "_fbMembers_@free.smarterpassword.com": {minVersion: "7.102.10.4936", installs: 644}, + "jid2-l8SPBzHJWBIiHQ@jetpack": {minVersion: "3.1", installs: 639}, + "{B17C1C5A-04B1-11DB-9804-B622A1EF5492}": {minVersion: "1.3.2", installs: 633}, + "myplaycitycom@gametab": {minVersion: "1.6", installs: 616}, + "{ad0d925d-88f8-47f1-85ea-8463569e756e}": {minVersion: "2.0.5", installs: 604}, + "{37964A3C-4EE8-47b1-8321-34DE2C39BA4D}": {minVersion: "2.5.4.174", installs: 603}, + "youtubemp3podcaster@jeremy.d.gregorio.com": {minVersion: "3.9.0", installs: 601}, + "caa1-aDOiCAxFFPRIVATE@jetpack": {minVersion: "0.2.0", installs: 598}, + "_f5Members_@free.typingfanatic.com": {minVersion: "7.102.10.5014", installs: 595}, + "_94Members_@www.motitags.com": {minVersion: "7.102.10.4744", installs: 594}, + "{888d99e7-e8b5-46a3-851e-1ec45da1e644}": {minVersion: "45.0.0", installs: 581}, + "_1cMembers_@www.bringmesports.com": {minVersion: "7.102.10.3646", installs: 580}, + "{a6fd85ed-e919-4a43-a5af-8da18bda539f}": {minVersion: "2.9.1.1-signed", installs: 572}, + "{0fc22c4c-93ed-48ea-ad12-dc8039cf3795}": {minVersion: "1.3", installs: 568}, + "homeutil@yandex.ru": {minVersion: "1.0.13", installs: 565}, + "_doMembers_@free.convertanyfile.com": {minVersion: "7.38.8.45860", installs: 563}, + "SocialNewPages-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 561}, + "wappalyzer@crunchlabz.com": {minVersion: "3.2.7", installs: 557}, + "_5qMembers_@www.zwinky.com": {minVersion: "7.38.8.45270", installs: 551}, + "{0545b830-f0aa-4d7e-8820-50a4629a56fe}": {minVersion: "31.0.9", installs: 531}, + "vk@sergeykolosov.mp": {minVersion: "0.3.9.5", installs: 522}, + "{77b819fa-95ad-4f2c-ac7c-486b356188a9}": {minVersion: "4.0.20130422.1-signed.1-signed", installs: 505}, + "@true-key": {minVersion: "1.23.0.2433", installs: 501}, + "_1pMembers_@www.referenceboss.com": {minVersion: "7.102.10.4932", installs: 499}, + "{C7AE725D-FA5C-4027-BB4C-787EF9F8248A}": {minVersion: "1.0.0.4", installs: 494}, + "alx-ffdeveloper@amazon.com": {minVersion: "3.0.2", installs: 493}, + "{3d7eb24f-2740-49df-8937-200b1cc08f8a}": {minVersion: "1.5.20", installs: 491}, + "_1gMembers_@www.inboxace.com": {minVersion: "7.38.8.56535", installs: 488}, + "{7DD78D43-0962-4d9b-BC76-ABF13B3B2ED1}": {minVersion: "3.5.0.1428", installs: 484}, + "imageblock@hemantvats.com": {minVersion: "3.1", installs: 472}, + "online_banking@kaspersky.com": {minVersion: "4.0.10.15", installs: 463}, + "virtual_keyboard@kaspersky.com": {minVersion: "4.0.10.15", installs: 463}, + "button@scholar.google.com": {minVersion: "1.1.1-signed.1-signed", installs: 463}, + "anti_banner@kaspersky.com": {minVersion: "4.0.10.15", installs: 462}, + "url_advisor@kaspersky.com": {minVersion: "4.0.10.15", installs: 461}, + "{6d96bb5e-1175-4ebf-8ab5-5f56f1c79f65}": {minVersion: "0.9.8", installs: 457}, + "_14Members_@download.totalrecipesearch.com": {minVersion: "7.102.10.4983", installs: 456}, + "{394DCBA4-1F92-4f8e-8EC9-8D2CB90CB69B}": {minVersion: "5.1.1", installs: 447}, + "_57Members_@free.marineaquariumfree.com": {minVersion: "7.102.10.4716", installs: 446}, + "e67f8350-7edf-11e3-baa7-0800200c9a66@fri-gate.org": {minVersion: "2.2.1.1-signed", installs: 446}, + "FireXPath@pierre.tholence.com": {minVersion: "0.9.7.1.1-signed.1-signed", installs: 442}, + "@youtube_downloader": {minVersion: "0.0.9", installs: 435}, + "ff_hpset@jetpack": {minVersion: "1.0.8", installs: 428}, + "{d0bfdcce-52c7-4b32-bb45-948f62db8d3f}": {minVersion: "49.1", installs: 406}, + "_j2Members_@www.soccerinferno.com": {minVersion: "7.102.10.4948", installs: 405}, + "autoform@olifozzy": {minVersion: "1.2.4.1-signed.1-signed", installs: 405}, + "FunSafeTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 405}, + "testpilot@labs.mozilla.com": {minVersion: "1.2.3.1-signed", installs: 405}, + "vwof@drev.com": {minVersion: "3.1.2", installs: 401}, + "_ftMembers_@free.mytelevisionhq.com": {minVersion: "7.102.10.4817", installs: 397}, + "{e001c731-5e37-4538-a5cb-8168736a2360}": {minVersion: "0.9.9.152", installs: 396}, + "{95E84BD3-3604-4AAC-B2CA-D9AC3E55B64B}": {minVersion: "2.0.0.78", installs: 393}, + "_8lMembers_@free.filesharefanatic.com": {minVersion: "7.102.10.4171", installs: 389}, + "clipconverter@clipconverter.cc": {minVersion: "1.5.2", installs: 387}, + "_7jMembers_@download.gardeningenthusiast.com": {minVersion: "7.102.10.4260", installs: 383}, + "antmark@ant.com": {minVersion: "1.1.14", installs: 383}, + "_flMembers_@free.myformsfinder.com": {minVersion: "7.102.10.4784", installs: 381}, + "{c36177c0-224a-11da-8cd6-0800200c9a91}": {minVersion: "3.9.85.1-signed.1-signed", installs: 375}, + "@searchincognito": {minVersion: "0.1.0", installs: 375}, + "{f13b157f-b174-47e7-a34d-4815ddfdfeb8}": {minVersion: "0.9.89.1-signed.1-signed", installs: 373}, + "_5eMembers_@www.translationbuddy.com": {minVersion: "7.38.8.45962", installs: 372}, + "{9c51bd27-6ed8-4000-a2bf-36cb95c0c947}": {minVersion: "11.0.1.1-signed.1-signed", installs: 370}, + "clickclean@hotcleaner.com": {minVersion: "4.1.1-signed.1-signed", installs: 366}, + "jid1-xKH0EoS44u1a2w@jetpack": {minVersion: "0.1.1-signed.1-signed", installs: 366}, + "{c2056674-a37f-4b29-9300-2004759d74fe}": {minVersion: "2.0.0.1090", installs: 361}, + "newtab-tv-the-extension1@mozilla.com": {minVersion: "0.1.5", installs: 359}, + "ascsurfingprotectionnew@iobit.com": {minVersion: "2.1.3", installs: 355}, + "FunTabSafe-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 353}, + "d.lehr@chello.at": {minVersion: "1.2", installs: 350}, + "anticontainer@downthemall.net": {minVersion: "1.5", installs: 348}, + "{F8A55C97-3DB6-4961-A81D-0DE0080E53CB}": {minVersion: "1.0.10", installs: 347}, + "@FormsApp": {minVersion: "0.2.0", installs: 346}, + "multilinksplus@hugsmile.eu": {minVersion: "3.9.3", installs: 343}, + "jid1-KWFaW5zc0EbtBQ@jetpack": {minVersion: "0.2.0", installs: 335}, + "{e8f509f0-b677-11de-8a39-0800200c9a66}": {minVersion: "1.12.1-signed.1-let-fixed.1-signed", installs: 334}, + "{37E4D8EA-8BDA-4831-8EA1-89053939A250}": {minVersion: "3.0.0.2.1-signed.1-signed", installs: 333}, + "{c8d3bc80-0810-4d21-a2c2-be5f2b2832ac}": {minVersion: "0.98", installs: 332}, + "{cb40da56-497a-4add-955d-3377cae4c33b}": {minVersion: "10.2.0.271", installs: 331}, + "{5546F97E-11A5-46b0-9082-32AD74AAA920}": {minVersion: "0.76.1-signed.1-signed", installs: 325}, + "_14Members_@www.totalrecipesearch.com": {minVersion: "7.38.8.45925", installs: 324}, + "info@mp3it.eu": {minVersion: "1.4.1.1-signed.1-signed", installs: 324}, + "firefox-autofill@googlegroups.com": {minVersion: "3.6.1-signed.1-signed", installs: 317}, + "jid1-TQvJxTBYHA8qXg@jetpack": {minVersion: "0.4.1-signed.1-signed", installs: 315}, + "{8f8fe09b-0bd3-4470-bc1b-8cad42b8203a}": {minVersion: "0.17.1-signed.1-signed", installs: 311}, + "{D4DD63FA-01E4-46a7-B6B1-EDAB7D6AD389}": {minVersion: "0.9.10.1-signed.1-signed", installs: 311}, + "{d7f46ca0-899d-11da-a72b-0800200c9a65}": {minVersion: "0.1.2.1-signed.1-signed", installs: 311}, + "twoo@twoo.com": {minVersion: "1.6.0.1-signed", installs: 303}, + "_29Members_@www.headlinealley.com": {minVersion: "7.38.8.56537", installs: 302}, + "_e2Members_@free.coolpopulargames.com": {minVersion: "7.38.8.45873", installs: 300}, + "TopTVTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 300}, + "tmbepff@trendmicro.com": {minVersion: "9.2.0.1026", installs: 293}, + "_2vMembers_@www.dailybibleguide.com": {minVersion: "7.38.8.52880", installs: 289}, + "{54e46280-0211-11e3-b778-0800200c9a66}": {minVersion: "0.3", installs: 285}, + "_49Members_@www.utilitychest.com": {minVersion: "7.38.8.45977", installs: 284}, + "amcontextmenu@loucypher": {minVersion: "0.4.2.1-signed.1-signed", installs: 284}, + "jid1-r1tDuNiNb4SEww@jetpack": {minVersion: "1.1.2673", installs: 283}, + "_erMembers_@free.getvideoconvert.com": {minVersion: "7.102.10.5038", installs: 281}, + "{b1df372d-8b32-4c7d-b6b4-9c5b78cf6fb1}": {minVersion: "0.87.1-signed.1-signed", installs: 281}, + "jid1-cHKBMlArKdIVEg@jetpack": {minVersion: "1.24.1-signed.1-signed", installs: 281}, + "@90B817C8-8A5C-413B-9DDD-B2C61ED6E79A": {minVersion: "1.09", installs: 278}, + "smarterwiki@wikiatic.com": {minVersion: "5.2.1.1-signed.1-signed", installs: 278}, + "whatsapppanel@alejandrobrizuela.com.ar": {minVersion: "1.1.1.1-signed.1-signed", installs: 277}, + "lazarus@interclue.com": {minVersion: "2.3.1-signed.1-signed", installs: 275}, + "{DEDA1132-B316-11DD-8BC1-4E5D56D89593}": {minVersion: "0.18", installs: 274}, + "_h2Members_@free.calendarspark.com": {minVersion: "7.102.10.3641", installs: 273}, + "@youtubedownloadere": {minVersion: "0.0.1", installs: 273}, + "multirevenue@googlemail.com": {minVersion: "6.1.1", installs: 272}, + "_d9Members_@www.everydaylookup.com": {minVersion: "7.102.10.4140", installs: 271}, + "belgiumeid@eid.belgium.be": {minVersion: "1.0.21", installs: 271}, + "{62DD0A97-FDD4-421b-94A5-D1A9434450C7}": {minVersion: "3.1", installs: 270}, + "the-addon-bar@GeekInTraining-GiT": {minVersion: "3.2.9-compat-fixed-4", installs: 264}, + "@phextension": {minVersion: "6.0.2", installs: 262}, + "FunMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 262}, + "{7f57cf46-4467-4c2d-adfa-0cba7c507e54}": {minVersion: "4.0.1", installs: 259}, + "safefacebook@bkav": {minVersion: "1.0.4", installs: 255}, + "content_blocker_6418E0D362104DADA084DC312DFA8ABC@kaspersky.com": {minVersion: "4.5.3.8", installs: 254}, + "virtual_keyboard_294FF26A1D5B455495946778FDE7CEDB@kaspersky.com": {minVersion: "4.5.3.8", installs: 254}, + "{B821BF60-5C2D-41EB-92DC-3E4CCD3A22E4}": {minVersion: "4.3.1.10", installs: 252}, + "@E9438230-A7DF-4D1F-8F2D-CA1D0F0F7924": {minVersion: "1.08.8.66", installs: 252}, + "jid1-6MGm94JnyY2VkA@jetpack": {minVersion: "2.1.8", installs: 250}, + "{20a82645-c095-46ed-80e3-08825760534b}": {minVersion: "1.3.1.1-signed", installs: 246}, + "{a192bf54-089f-4325-ac25-7eafcd17a342}": {minVersion: "3.2", installs: 246}, + "e389d8c2-5554-4ba2-a36e-ac7a57093130@gmail.com": {minVersion: "1.44.275", installs: 244}, + "yslow@yahoo-inc.com": {minVersion: "3.1.8.1-signed.1-signed", installs: 244}, + "avg@safeguard": {minVersion: "19.6.0.592", installs: 243}, + "@windscribeff": {minVersion: "0.1.43", installs: 242}, + "jid1-PBNne26X1Kn6hQ@jetpack": {minVersion: "3.3.3", installs: 240}, + "{53A03D43-5363-4669-8190-99061B2DEBA5}": {minVersion: "1.5.14", installs: 239}, + "@offersolymp": {minVersion: "0.0.2", installs: 238}, + "firefox@dotvpn.com": {minVersion: "1.0.2", installs: 238}, + "{62760FD6-B943-48C9-AB09-F99C6FE96088}": {minVersion: "4.2.9", installs: 236}, + "jid1-sNL73VCI4UB0Fw@jetpack": {minVersion: "2.1.4", installs: 236}, + "low_quality_flash@pie2k.com": {minVersion: "0.2.1-signed.1-signed", installs: 236}, + "jid1-l6VQSR2FeKnliQ@jetpack": {minVersion: "2.0.1-signed", installs: 235}, + "_5zMembers_@www.couponxplorer.com": {minVersion: "7.102.10.3738", installs: 234}, + "adonis.cuhk@gmail.com": {minVersion: "1.8.9.1-signed.1-signed", installs: 234}, + "_e1Members_@free.actionclassicgames.com": {minVersion: "7.38.8.45834", installs: 232}, + "{ea4637dc-e014-4c17-9c2c-879322d23268}": {minVersion: "2.1.1-signed.1-signed", installs: 229}, + "{4DC70064-89E2-4a55-8FC6-E8CDEAE3618C}": {minVersion: "0.7.7.1-signed.1-signed", installs: 228}, + "odyssey_crypto_control@odysseytec.com": {minVersion: "3.5", installs: 228}, + "seostatus@rubyweb": {minVersion: "1.5.9.1-signed.1-signed", installs: 228}, + "_apMembers_@free.puzzlegamesdaily.com": {minVersion: "7.102.10.4865", installs: 227}, + "@safesearchincognito": {minVersion: "0.1.8", installs: 226}, + "jid1-HfCj61J5q2gaGQ@jetpack": {minVersion: "1.0.3", installs: 224}, + "@stopads": {minVersion: "0.0.4", installs: 224}, + "dta3noaero@vano": {minVersion: "1.0.1", installs: 224}, + "rainbow@colors.org": {minVersion: "1.6.1-signed.1-signed", installs: 223}, + "{146f1820-2b0d-49ef-acbf-d85a6986e10c}": {minVersion: "0.1.9.3.1-signed.1-signed", installs: 222}, + "{b2bfe60c-eef8-4e20-8334-c53afdc1ffdd}": {minVersion: "3.2", installs: 222}, + "{b7870b41-bfb3-44cd-8cc2-e392e51b0874}": {minVersion: "3.8", installs: 222}, + "printPages2Pdf@reinhold.ripper": {minVersion: "0.1.9.3.1-signed", installs: 221}, + "YouTubetoALL@ALLPlayer.org": {minVersion: "0.8.5.1-signed.1-signed", installs: 221}, + "{7a526449-3a92-426f-8ca4-47439918f2b1}": {minVersion: "3.2", installs: 219}, + "jdwimqhayu@yahoo.com": {minVersion: "0.0.0.6", installs: 219}, + "{54FBE89E-C878-46bb-A064-AB327EE26EBC}": {minVersion: "3.8", installs: 214}, + "modernDownloadManager@teo.pl": {minVersion: "0.2.2", installs: 214}, + "{eb8fff7e-1dce-4f3f-a51d-d9513ed6bab4}": {minVersion: "3.8", installs: 211}, + "jid0-YQz0l1jthOIz179ehuitYAOdBEs@jetpack": {minVersion: "2.0.2", installs: 211}, + "{7e80e173-7e63-464e-8252-fe170b15c15a}": {minVersion: "2.3", installs: 210}, + "{35d6291e-1d4b-f9b4-c52f-77e6410d1326}": {minVersion: "4.11.1.0", installs: 209}, + "{3c59c791-aeec-44bb-af60-ff112eea18e3}": {minVersion: "3.2", installs: 209}, + "{90477448-b59c-48cd-98af-6a298cbc15d2}": {minVersion: "3.8", installs: 209}, + "{24d26487-6274-48b1-b500-22f24884f971}": {minVersion: "2.3", installs: 208}, + "{b7389dbc-6646-412f-bbd5-53168ee68a98}": {minVersion: "49", installs: 208}, + "{22181a4d-af90-4ca3-a569-faed9118d6bc}": {minVersion: "11.0.0.1181", installs: 207}, + "printpdf@pavlov.net": {minVersion: "0.76.1-signed.1-signed", installs: 207}, + "@com.virtualjame.disableads": {minVersion: "0.1.0", installs: 206}, + "{9AA46F4F-4DC7-4c06-97AF-6665170634FE}": {minVersion: "1.11.6.1-signed.1-signed", installs: 205}, + "tinyjsdebugger@enigmail.net": {minVersion: "1.1.5", installs: 204}, + "_foMembers_@free.flightsearchapp.com": {minVersion: "7.102.10.4176", installs: 202}, + "jid1-rs90nxQtPi3Asg@jetpack": {minVersion: "1.8.1-signed.1-signed", installs: 201}, + "vlcplaylist@helgatauscher.de": {minVersion: "0.8.1-signed.1-signed", installs: 201}, + "jid1-G80Ec8LLEbK5fQ@jetpack": {minVersion: "1.3.8", installs: 200}, + "_gpMembers_@free.mymapswizard.com": {minVersion: "7.102.10.4775", installs: 199}, + "BestMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 199}, + "info@convert2mp3.net": {minVersion: "2.5.1-signed.1-signed", installs: 199}, + "partnerdefaults@mozilla.com": {minVersion: "1.0.1", installs: 199}, + "qwantcomforfirefox@jetpack": {minVersion: "3.0.28", installs: 199}, + "{65e41d20-f092-41b7-bb83-c6e8a9ab0f57}": {minVersion: "1.2.6", installs: 198}, + "amznUWL2@amazon.com": {minVersion: "1.11", installs: 197}, + "{1b80ae74-4912-44fc-9f27-30f9252a5ad7}": {minVersion: "2.3", installs: 197}, + "{c9b4cd26-6f0e-4972-a9e0-8b77e811aa8f}": {minVersion: "2.3", installs: 197}, + "shopcbtoolbar2@befrugal.com": {minVersion: "2013.3.23.1", installs: 197}, + "trafficlight@bitdefender.com": {minVersion: "0.2.23.1-signed.1-signed", installs: 197}, + "webrank-toolbar@probcomp.com": {minVersion: "4.4.1.1-signed.1-signed", installs: 197}, + "_4lMembers_@www.bibletriviatime.com": {minVersion: "7.102.10.4330", installs: 196}, + "xthunder@lshai.com": {minVersion: "1.3.4.1-signed.1-signed", installs: 196}, + "extension@hidemyass.com": {minVersion: "1.3.2", installs: 195}, + "jid1-MIAJd5BiK7V4Pw@jetpack": {minVersion: "0.9.1-signed.1-signed", installs: 195}, + "{51aa69f8-8825-4def-916a-a766c5e3c0fd}": {minVersion: "3.8", installs: 194}, + "{2bc72c53-9bde-4db2-8479-eda9a5e71f4e}": {minVersion: "3.2", installs: 193}, + "{a95d8332-e4b4-6e7f-98ac-20b733364387}": {minVersion: "1.0.5", installs: 191}, + "ocr@babylon.com": {minVersion: "1.1", installs: 191}, + "{d3b9472c-f8b1-4a10-935b-1087bac8417f}": {minVersion: "3.8", installs: 189}, + "windowpromo@dm73.net": {minVersion: "1.6", installs: 188}, + "alldownloader@link64": {minVersion: "1.00.17.1-signed.1-signed", installs: 187}, + "{3e0e7d2a-070f-4a47-b019-91fe5385ba79}": {minVersion: "3.6.5.2", installs: 185}, + "jid1-vFmnfCkyf5VeSA@jetpack": {minVersion: "0.4.0", installs: 185}, + "@greatdealz": {minVersion: "0.0.3", installs: 184}, + "superstart@enjoyfreeware.org": {minVersion: "7.4.0.1-signed", installs: 183}, + "{c2fc3c2b-a65a-453c-bf95-101fde56ed1d}": {minVersion: "2.3", installs: 182}, + "{53152e75-fd90-472f-9d30-5cba3679eab9}": {minVersion: "48.3", installs: 180}, + "jid0-raWjElI57dRa4jx9CCiYm5qZUQU@jetpack": {minVersion: "3.0.12.1.1-signed.1-signed", installs: 180}, + "_ivMembers_@free.simplepictureedit.com": {minVersion: "7.102.10.14166", installs: 179}, + "jid1-wKRSK9TpFpr9Hw@jetpack": {minVersion: "0.92", installs: 179}, + "emailExtractor@penzil.com": {minVersion: "1.3.1-signed.1-signed", installs: 178}, + "{60B7679C-BED9-11E5-998D-8526BB8E7F8B}": {minVersion: "6.3", installs: 177}, + "@pdfit": {minVersion: "0.1.9", installs: 177}, + "jid1-6AyZ1PQXsR9LgQ@jetpack": {minVersion: "0.2.1", installs: 177}, + "_6oMembers_@free.heroicplay.com": {minVersion: "7.38.8.46626", installs: 175}, + "{4BBDD651-70CF-4821-84F8-2B918CF89CA3}": {minVersion: "8.9.3.1", installs: 173}, + "jid1-GeRCnsiDhZiTvA@jetpack": {minVersion: "1.0.3", installs: 172}, + "jid0-zs24wecdcQo0Lp18D7QOV4WSZFo@jetpack": {minVersion: "0.2.1-signed.1-signed", installs: 171}, + "{c50ca3c4-5656-43c2-a061-13e717f73fc8}": {minVersion: "5.0.1.48.1-signed.1-signed", installs: 170}, + "selenium_ide_buttons@egarracingteam.com.ar": {minVersion: "1.2.0.1-signed.1-signed", installs: 170}, + "WSVCU@Wondershare.com": {minVersion: "7.1.0", installs: 169}, + "{4cc4a13b-94a6-7568-370d-5f9de54a9c7f}": {minVersion: "2.7.1-signed.1-signed", installs: 168}, + "{aa84ce40-4253-a00a-8cd6-0800200f9a67}": {minVersion: "3.12.0", installs: 168}, + "FasterFox_Lite@BigRedBrent": {minVersion: "3.9.9Lite.1-signed.1-signed", installs: 167}, + "{6cc0f0f7-a6e2-4834-9682-24de2229b51e}": {minVersion: "23.6", installs: 166}, + "{b749fc7c-e949-447f-926c-3f4eed6accfe}": {minVersion: "0.7.1.1.1-signed.1-signed", installs: 166}, + "@mendeleyimporter": {minVersion: "1.6.8", installs: 166}, + "ALone-live@ya.ru": {minVersion: "1.4.11", installs: 166}, + "{4093c4de-454a-4329-8aff-c6b0b123c386}": {minVersion: "0.8.14.1-signed.1-signed", installs: 165}, + "cookiemgr@jayapal.com": {minVersion: "5.12", installs: 164}, + "touchenex@raon.co.kr": {minVersion: "1.0.1.11", installs: 163}, + "{b0e1b4a6-2c6f-4e99-94f2-8e625d7ae255}": {minVersion: "3.5.0.1-signed.1-signed", installs: 162}, + "isreaditlater@ideashower.com": {minVersion: "3.0.6.1-signed", installs: 161}, + "safesearchplus@avira.com": {minVersion: "1.4.1.371", installs: 161}, + "_e0Members_@www.downshotfree.com": {minVersion: "7.102.10.3833", installs: 159}, + "LDSI_plashcor@gmail.com": {minVersion: "1.1.0.3", installs: 159}, + "jid1-9ETkKdBARv7Iww@jetpack": {minVersion: "0.20.1-signed.1-signed", installs: 157}, + "jid1-CGxMej0nDJTjwQ@jetpack": {minVersion: "1.0.1-signed.1-signed", installs: 157}, + "{00f7ab9f-62f4-4145-b2f9-38d579d639f6}": {minVersion: "49", installs: 156}, + "googledictionary@toptip.ca": {minVersion: "7.5", installs: 156}, + "shopearn@prodege.com": {minVersion: "219", installs: 156}, + "fvdmedia@gmail.com": {minVersion: "11.0.1", installs: 155}, + "magicplayer_unlisted@acestream.org": {minVersion: "1.1.42", installs: 155}, + "{0538E3E3-7E9B-4d49-8831-A227C80A7AD3}": {minVersion: "2.2.2.1-signed.1-let-fixed.1-signed", installs: 154}, + "{73007fef-a6e0-47d3-b4e7-dfc116ed6f65}": {minVersion: "1.15.1-signed.1-signed", installs: 153}, + "{cd617372-6743-4ee4-bac4-fbf60f35719e}": {minVersion: "2.0.1-signed.1-signed", installs: 152}, + "TopSecurityTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 152}, + "jid1-hDf2iQXGiUjzGQ@jetpack": {minVersion: "2.5.0", installs: 151}, + "_dnMembers_@www.free.webmailworld.com": {minVersion: "7.102.10.5052", installs: 149}, + "jid1-rrMTK7JqsxNOeQ@jetpack": {minVersion: "2.1.0", installs: 149}, + "jid1-XgC5trUcILmXBw@jetpack": {minVersion: "2.0.3", installs: 149}, + "online_banking_69A4E213815F42BD863D889007201D82@kaspersky.com": {minVersion: "4.5.3.8", installs: 148}, + "jid1-AXn9cXcB4fD1QQ@jetpack": {minVersion: "0.7.4", installs: 148}, + "feedly@devhd": {minVersion: "16.0.528.1-signed.1-signed", installs: 147}, + "{6E727987-C8EA-44DA-8749-310C0FBE3C3E}": {minVersion: "2.0.0.11", installs: 146}, + "{1082eb84-f0f2-11e5-8e18-9bb85ab7992e}": {minVersion: "1.07", installs: 146}, + "{c151d79e-e61b-4a90-a887-5a46d38fba99}": {minVersion: "2.8.8", installs: 146}, + "public.proartex@gmail.com": {minVersion: "1.1.3", installs: 145}, + "jid1-8J7ayxTha4KqKQ@jetpack": {minVersion: "1.1.1-signed.1-signed", installs: 144}, + "stealthyextension@gmail.com": {minVersion: "3.0.1.1-signed", installs: 144}, + "_beMembers_@free.dailylocalguide.com": {minVersion: "7.38.9.7920", installs: 143}, + "mytube@ashishmishra.in": {minVersion: "0.979.1-signed.1-signed", installs: 142}, + "@A3592ADB-854A-443A-854E-EB92130D470D": {minVersion: "1.08.8.88", installs: 139}, + "FunkyTVTabs-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 139}, + "jid1-QpHD8URtZWJC2A@jetpack": {minVersion: "4.3.0", installs: 138}, + "savedeo-video-downloader@fczbkk.com": {minVersion: "0.4.1.1-signed.1-signed", installs: 137}, + "toolbar@shopathome.com": {minVersion: "8.20.3.1", installs: 137}, + "_dyMembers_@www.dezipper.com": {minVersion: "7.102.10.3775", installs: 135}, + "jid0-zXo3XFGyiDalgkeEO4UYJTUwo2I@jetpack": {minVersion: "1.0.0", installs: 134}, + "{d57c9ff1-6389-48fc-b770-f78bd89b6e8a}": {minVersion: "1.46.1-signed.1-signed", installs: 133}, + "@searchlock-fx": {minVersion: "1.1.6", installs: 133}, + "dm@jetpack": {minVersion: "0.0.2", installs: 133}, + "proxyselector@mozilla.org": {minVersion: "1.31.1-signed.1-signed", installs: 133}, + "{065829BC-17B5-4C0B-9429-3173C361092E}": {minVersion: "1.0.8", installs: 132}, + "{ada4b710-8346-4b82-8199-5de2b400a6ae}": {minVersion: "2.1.5.5.3", installs: 132}, + "readable@evernote.com": {minVersion: "10.2.1.7.1-signed", installs: 131}, + "{d48a39ba-8f80-4fce-8ee1-bc710561c55d}": {minVersion: "3.1.0.1-signed.1-signed", installs: 131}, + "autorefresh@plugin": {minVersion: "1.0.2.1-signed.1-signed", installs: 130}, + "SafeBrowseSearch-the-extension1@mozilla.com": {minVersion: "0.1.2", installs: 130}, + "browsermodulecorp@browcorporation.org": {minVersion: "2.3", installs: 129}, + "wisestamp@wisestamp.com": {minVersion: "4.14.20", installs: 127}, + "_63Members_@www.aplusgamer.com": {minVersion: "7.38.8.45832", installs: 126}, + "bestproxyswitcher@bestproxyswitcher.com": {minVersion: "3.4.6.1-signed.1-signed", installs: 126}, + "jid1-AVgCeF1zoVzMjA@jetpack": {minVersion: "0.9.5.6", installs: 126}, + "{ce7e73df-6a44-4028-8079-5927a588c948}": {minVersion: "1.1.4", installs: 125}, + "{E71B541F-5E72-5555-A47C-E47863195841}": {minVersion: "3.0.3", installs: 125}, + "{F5DDF39C-9293-4d5e-9AA8-E04E6DD5E9B4}": {minVersion: "1.6.3.1-signed.1-signed", installs: 125}, + "@simplepopupblocker": {minVersion: "1.2.1", installs: 125}, + "commonfix@mozillaonline.com": {minVersion: "0.13", installs: 125}, + "searchme@mybrowserbar.com": {minVersion: "2.8", installs: 125}, + "_4wMembers_@www.retrogamer.com": {minVersion: "7.38.8.46604", installs: 124}, + "{71328583-3CA7-4809-B4BA-570A85818FBB}": {minVersion: "0.8.6.3.1-let-fixed", installs: 123}, + "dmremote@westbyte.com": {minVersion: "1.9.3", installs: 123}, + "@google-translate-menu": {minVersion: "1.0.1", installs: 122}, + "_aaMembers_@free.eliteunzip.com": {minVersion: "7.39.8.50909", installs: 121}, + "{8620c15f-30dc-4dba-a131-7c5d20cf4a29}": {minVersion: "3.9", installs: 121}, + "{eb4b28c8-7f2d-4327-a00c-40de4299ba44}": {minVersion: "1.7", installs: 121}, + "flashlight@stephennolan.com.au": {minVersion: "1.2.1-signed.1-signed", installs: 121}, + "useragentoverrider@qixinglu.com": {minVersion: "0.4.1", installs: 121}, + "{1B33E42F-EF14-4cd3-B6DC-174571C4349C}": {minVersion: "4.7", installs: 120}, + "_dxMembers_@www.download-freemaps.com": {minVersion: "7.38.8.46371", installs: 120}, + "{95ab36d4-fb6f-47b0-8b8d-e5f3bd547953}": {minVersion: "4.20.13.1-signed.1-signed", installs: 120}, + "FirefoxAddon@similarWeb.com": {minVersion: "4.0.6", installs: 120}, + "flashstopper@byo.co.il": {minVersion: "1.4.2", installs: 120}, + "{15e67a59-bd3d-49ae-90dd-b3d3fd14c2ed}": {minVersion: "1.0.3.1-signed.1-signed", installs: 119}, + "{c37bac34-849a-4d28-be41-549b2c76c64e}": {minVersion: "2.6", installs: 119}, + "{03B08592-E5B4-45ff-A0BE-C1D975458688}": {minVersion: "1.1.1-signed.1-signed", installs: 118}, + "newtabgoogle@graememcc.co.uk": {minVersion: "1.0.2.1-signed.1-signed", installs: 118}, + "SocialNewtabs-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 118}, + "@kikikokicicidada": {minVersion: "2.1.2", installs: 117}, + "{9D6218B8-03C7-4b91-AA43-680B305DD35C}": {minVersion: "4.0.5", installs: 116}, + "extension@one-tab.com": {minVersion: "1.17.0", installs: 116}, + "{22119944-ED35-4ab1-910B-E619EA06A115}": {minVersion: "7.9.21.5", installs: 115}, + "admin@hide-my-ip.org": {minVersion: "9.6.3", installs: 115}, + "bdwteffv19@bitdefender.com": {minVersion: "2.2.1", installs: 115}, + "exif_viewer@mozilla.doslash.org": {minVersion: "2.00.1-signed.1-signed", installs: 115}, + "MyStartab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 115}, + "coralietab@mozdev.org": {minVersion: "2.04.20110724.1-signed.1-signed", installs: 113}, + "gaurangnshah@gmail.com": {minVersion: "1.3.2.1-signed.1-signed", installs: 113}, + "ImagePicker@topolog.org": {minVersion: "1.9.4", installs: 113}, + "{d49a148e-817e-4025-bee3-5d541376de3b}": {minVersion: "3.1.1-signed.1-signed", installs: 112}, + "firebug@tools.sitepoint.com": {minVersion: "1.6.1-signed.1-signed", installs: 111}, + "add-to-searchbox@maltekraus.de": {minVersion: "2.9", installs: 110}, + "captiondownloader@hiephm.com": {minVersion: "2.3.1-signed.1-signed", installs: 110}, + "jid1-LYopfl0r00ZV5k@jetpack": {minVersion: "1.0.1-signed.1-signed", installs: 110}, + "{7CA9CF31-1C73-46CD-8377-85AB71EA771F}": {minVersion: "5.0.12", installs: 109}, + "jid1-HdwPLukcGQeOSh@jetpack": {minVersion: "1.2.3", installs: 108}, + "{0AA9101C-D3C1-4129-A9B7-D778C6A17F82}": {minVersion: "2.09.1-signed", installs: 107}, + "CookiesIE@yahoo.com": {minVersion: "1.0.1-signed.1-signed", installs: 107}, + "selenium-expert_selenium-ide@Samit.Badle": {minVersion: "0.25.1-signed.1-signed", installs: 107}, + "{19EB90DC-A456-458b-8AAC-616D91AAFCE1}": {minVersion: "1.0.1-signed", installs: 105}, + "application@itineraire.info": {minVersion: "4.5.0", installs: 105}, + "rest-easy@quickmediasolutions.com": {minVersion: "0.3.1.1-signed", installs: 105}, + "TopSocialHub-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 105}, + "{7affbfae-c4e2-4915-8c0f-00fa3ec610a1}": {minVersion: "6.36.32", installs: 104}, + "azhang@cloudacl.com": {minVersion: "0.19.6.9.1-signed.1-signed", installs: 104}, + "FunCyberTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 104}, + "SkipScreen@SkipScreen": {minVersion: "0.7.2.1-signed.1-signed", installs: 104}, + "toolbar@seomoz.org": {minVersion: "3.1.18", installs: 104}, + "{8b86149f-01fb-4842-9dd8-4d7eb02fd055}": {minVersion: "0.26.1-signed.1-signed", installs: 103}, + "fbp@fbpurity.com": {minVersion: "9.3.2.1-signed", installs: 103}, + "jid1-V8ev2melBDV3qQ@jetpack": {minVersion: "1.0.12.1-signed.1-signed", installs: 103}, + "_fvMembers_@free.directionsace.com": {minVersion: "7.102.10.3790", installs: 102}, + "{b6b1a201-b252-484f-b9fe-68efbb273fbd}": {minVersion: "1.10.1-signed.1-signed", installs: 102}, + "flashfirebug@o-minds.com": {minVersion: "4.9.1", installs: 102}, + "_ebMembers_@download.metrohotspot.com": {minVersion: "7.102.10.4735", installs: 101}, + "{2e17e2b2-b8d4-4a67-8d7b-fafa6cc9d1d0}": {minVersion: "1.2.7.0.1-signed.1-signed", installs: 101}, + "{ea61041c-1e22-4400-99a0-aea461e69d04}": {minVersion: "0.2.4.1-signed.1-signed", installs: 101}, + "rapportive@rapportive.com": {minVersion: "1.4.0.1.1-signed.1-signed", installs: 101}, + "_dvMembers_@www.testinetspeed.com": {minVersion: "7.38.8.45918", installs: 100}, + "{9aad3da6-6c46-4ef0-9109-6df5eaaf597c}": {minVersion: "1.4.1.1-signed.1-signed", installs: 100}, + "{c2b1f3ae-5cd5-49b7-8a0c-2c3bcbbbb294}": {minVersion: "1.1.1-signed.1-signed", installs: 100}, + "jid0-w1UVmoLd6VGudaIERuRJCPQx1dQ@jetpack": {minVersion: "1.6.8.1-signed", installs: 100}, + "_cxMembers_@www.autopcbackup.com": {minVersion: "7.102.10.3597", installs: 99}, + "vpn@hide-my-ip.org": {minVersion: "10.6.2", installs: 99}, + "{1a5dabbd-0e74-41da-b532-a364bb552cab}": {minVersion: "1.0.9.1-signed", installs: 98}, + "FirePHPExtension-Build@firephp.org": {minVersion: "0.7.4.1-signed.1-signed", installs: 98}, + "jid1-UXDr6c69BeyPVw@jetpack": {minVersion: "0.8.2", installs: 98}, + "TopSafeTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 98}, + "{3b56bcc7-54e5-44a2-9b44-66c3ef58c13e}": {minVersion: "0.9.7.4", installs: 97}, + "autoreload@yz.com": {minVersion: "1.21", installs: 97}, + "manish.p05@gmail.com": {minVersion: "12.9", installs: 97}, + "videoresumer@jetpack": {minVersion: "1.1.4", installs: 97}, + "@Radio": {minVersion: "0.2.0", installs: 96}, + "_hfMembers_@free.everydaymanuals.com": {minVersion: "7.102.10.4142", installs: 96}, + "jid0-jJRRRBMgoShUhb07IvnxTBAl29w@jetpack": {minVersion: "2.0.4", installs: 96}, + "rikaichan-jpen@polarcloud.com": {minVersion: "2.01.160101", installs: 96}, + "{7c6cdf7c-8ea8-4be7-ae5a-0b3effe14d66}": {minVersion: "49.1", installs: 95}, + "{FDBAD97E-A258-4fe3-9CF6-60CF386C4422}": {minVersion: "2.0.1.6", installs: 95}, + "intgcal@egarracingteam.com.ar": {minVersion: "1.5.1", installs: 95}, + "MediaNewTab-the-extension1@mozilla.com": {minVersion: "0.1.6", installs: 95}, + "{9EB34849-81D3-4841-939D-666D522B889A}": {minVersion: "2.4.0.157", installs: 94}, + "{158d7cb3-7039-4a75-8e0b-3bd0a464edd2}": {minVersion: "2.7.1-signed.1-signed", installs: 94}, + "jid1-ach2kaGSshPJCg@jetpack": {minVersion: "0.1.1-signed.1-signed", installs: 94}, + "jid1-cwbvBTE216jjpg@jetpack": {minVersion: "2.1.0.1-signed.1-signed", installs: 94}, + "{f36c6cd1-da73-491d-b290-8fc9115bfa55}": {minVersion: "3.0.9.1-signed.1-let-fixed.1-signed", installs: 93}, + "dmpluginff@westbyte.com": {minVersion: "1.4.12", installs: 93}, + "firefox@serptrends.com": {minVersion: "0.8.14", installs: 93}, + "panel-plugin@effectivemeasure.com": {minVersion: "4.0.0", installs: 93}, + "_evMembers_@www.free.bestbackground.com": {minVersion: "7.102.10.3607", installs: 92}, + "canitbecheaper@trafficbroker.co.uk": {minVersion: "3.9.78", installs: 92}, + "favorites_selenium-ide@Samit.Badle": {minVersion: "2.0.1-signed.1-signed", installs: 92}, + "{5F590AA2-1221-4113-A6F4-A4BB62414FAC}": {minVersion: "0.45.8.20130519.3.1-signed.1-signed", installs: 90}, + "{3e9bb2a7-62ca-4efa-a4e6-f6f6168a652d}": {minVersion: "2.7.7.1-signed.1-signed", installs: 90}, + "{ab4b5718-3998-4a2c-91ae-18a7c2db513e}": {minVersion: "1.2.0.1-signed.1-signed", installs: 90}, + "2020Player_WEB@2020Technologies.com": {minVersion: "5.0.94.0", installs: 90}, + "translator@dontfollowme.net": {minVersion: "2.0.5", installs: 90}, + "YouTubeAutoReplay@arikv.com": {minVersion: "3.3.1-signed.1-signed", installs: 90}, + "{a949831f-d9c0-45ae-8c60-91c2a86fbfb6}": {minVersion: "0.2.1-signed.1-signed", installs: 89}, + "@vpn-unlimited-secure-proxy": {minVersion: "4.4", installs: 89}, + "jid1-JcGokIiQyjoBAQ@jetpack": {minVersion: "0.6.1-signed.1-signed", installs: 89}, + "_73Members_@www.easyhomedecorating.com": {minVersion: "7.102.10.4129", installs: 88}, + "{065ee92a-ad57-42a2-b6d5-466b6fd8e24d}": {minVersion: "0.11.6.1-signed.1-signed", installs: 88}, + "{455D905A-D37C-4643-A9E2-F6FEFAA0424A}": {minVersion: "0.8.17.1-signed.1-signed", installs: 88}, + "{7eb3f691-25b4-4a85-9038-9e57e2bcd537}": {minVersion: "0.4.4.1-signed.1-signed", installs: 88}, + "FunSocialTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 88}, + "Lucifox@lucidor.org": {minVersion: "0.9.13", installs: 88}, + "YourMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 88}, + "youtube-video-player@lejenome.me": {minVersion: "0.2.38.1-signed.1-signed", installs: 88}, + "_hgMembers_@free.atozmanuals.com": {minVersion: "7.102.10.3604", installs: 87}, + "abb-acer@amazon.com": {minVersion: "10.161.13.1002", installs: 87}, + "gmail_panel@alejandrobrizuela.com.ar": {minVersion: "1.2.0", installs: 87}, + "izer@camelcamelcamel.com": {minVersion: "2.8.2", installs: 87}, + "tvnewtab-the-extension1@mozilla.com": {minVersion: "0.1.5", installs: 87}, + "vlc_shortcut@kosan.kosan": {minVersion: "0.8.3.0", installs: 87}, + "youtubeunblocker@unblocker.yt": {minVersion: "0.6.20", installs: 86}, + "email@jetpack": {minVersion: "0.0.16", installs: 86}, + "extensions@gismeteo.com": {minVersion: "5.1.0.2", installs: 86}, + "idaremote@westbyte.com": {minVersion: "1.6.3", installs: 86}, + "{725fc0a6-1f6b-4cf9-ae17-748d111dc16d}": {minVersion: "1.1.0", installs: 85}, + "jid1-461B0PwxL3oTt1@jetpack": {minVersion: "0.2.1-signed.1-signed", installs: 85}, + "webdavlauncher@benryan.com": {minVersion: "1.1.0", installs: 85}, + "jid1-ZM3BerwS6FsQAg@jetpack": {minVersion: "0.4.1-signed", installs: 84}, + "_fwMembers_@free.howtosuite.com": {minVersion: "7.102.10.4280", installs: 84}, + "{023e9ca0-63f3-47b1-bcb2-9badf9d9ef28}": {minVersion: "4.4.3.1-signed.1-signed", installs: 84}, + "{25A1388B-6B18-46c3-BEBA-A81915D0DE8F}": {minVersion: "1.7.8.5.1-signed.1-signed", installs: 84}, + "{75493B06-1504-4976-9A55-B6FE240FF0BF}": {minVersion: "3.4.0.0", installs: 84}, + "facepaste.firefox.addon@azabani.com": {minVersion: "2.91", installs: 84}, + "jid1-cplLTTY501TB2Q@jetpack": {minVersion: "0.5.1", installs: 84}, + "_d1Members_@free.mysocialshortcut.com": {minVersion: "7.102.10.4792", installs: 83}, + "{761a54f1-8ccf-4112-9e48-dbf72adf6244}": {minVersion: "2.3.1-signed.1-signed", installs: 83}, + "{BBB77B49-9FF4-4d5c-8FE2-92B1D6CD696C}": {minVersion: "2.0.0.1083", installs: 83}, + "{a3a5c777-f583-4fef-9380-ab4add1bc2a2}": {minVersion: "2.1.4", installs: 82}, + "{eb80b076-a444-444c-a590-5aee5d977d80}": {minVersion: "2.6.18", installs: 82}, + "KVAllmytube@KeepVid.com": {minVersion: "4.10.0", installs: 82}, + "lumerias-instagram@lumerias.com": {minVersion: "1.3", installs: 82}, + "omnibar@ajitk.com": {minVersion: "0.7.28.20141004.1-signed.1-signed", installs: 81}, + "@autofillanyforms-easytatkal": {minVersion: "7.51.0", installs: 81}, + "@youtuberightclick": {minVersion: "0.0.3", installs: 81}, + "autoproxy@autoproxy.org": {minVersion: "0.4b2.2013051811.1-signed.1-let-fixed.1-signed", installs: 80}, + "{e33788ea-0bb9-4502-9c77-bdc551afc8ad}": {minVersion: "1.0.4", installs: 80}, + "dmmm@westbyte.com": {minVersion: "1.3.4", installs: 80}, + "easycopy@smokyink.com": {minVersion: "2.7.0", installs: 80}, + "jid1-LelsJ0Oz0rt71A@jetpack": {minVersion: "2.0.0", installs: 80}, + "_f7Members_@download.smsfrombrowser.com": {minVersion: "7.38.8.45917", installs: 79}, + "{6614d11d-d21d-b211-ae23-815234e1ebb5}": {minVersion: "3.9.13", installs: 79}, + "FunTvTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 79}, + "{4204c864-50bf-467a-95b3-0912b7f15869}": {minVersion: "1.2.00.1-signed.1-signed", installs: 78}, + "{987311C6-B504-4aa2-90BF-60CC49808D42}": {minVersion: "3.1-signed.1-signed", installs: 78}, + "uploader@adblockfilters.mozdev.org": {minVersion: "2.1.1-signed.1-let-fixed.1-signed", installs: 77}, + "PageRank@addonfactory.in": {minVersion: "2.0.1-signed.1-signed", installs: 77}, + "restartbutton@strk.jp": {minVersion: "0.1.5.1-signed.1-signed", installs: 77}, + "text2voice@vik.josh": {minVersion: "1.15", installs: 77}, + "_dpMembers_@free.findyourmaps.com": {minVersion: "7.102.10.4185", installs: 76}, + "53ffxtbr@www.dailyfitnesscenter.com": {minVersion: "7.36.8.15623", installs: 76}, + "gary@builtwith.com": {minVersion: "1.9.6.1-signed.1-signed", installs: 76}, + "idamm@westbyte.com": {minVersion: "1.3.2", installs: 76}, + "jid1-3gu11JeYBiIuJA@jetpack": {minVersion: "3.1.1", installs: 76}, + "jid1-zV8eHYwTDNUtwQ@jetpack": {minVersion: "1.0.4", installs: 76}, + "nst@neiron.ru": {minVersion: "7.3.0.2", installs: 76}, + "service@touchpdf.com": {minVersion: "1.15.1-signed.1-signed", installs: 76}, + "{02450954-cdd9-410f-b1da-db804e18c671}": {minVersion: "0.96.3.1-signed.1-signed", installs: 75}, + "{4176DFF4-4698-11DE-BEEB-45DA55D89593}": {minVersion: "0.8.50.1-signed.1-signed", installs: 75}, + "{DAD0F81A-CF67-4eed-98D6-26F6E47274CA}": {minVersion: "1.8.1-signed.1-signed", installs: 75}, + "dealxplorermysites770@yahoo.com": {minVersion: "0.0.0.1", installs: 75}, + "firefox@online-convert.com": {minVersion: "1.4.1-signed.1-signed", installs: 75}, + "jid1-zmgYgiQPXJtjNA@jetpack": {minVersion: "1.23", installs: 75}, + "_evMembers_@www.bestbackground.com": {minVersion: "7.38.9.7654", installs: 74}, + "dmbarff@westbyte.com": {minVersion: "1.5.11", installs: 74}, + "inf@youtube-mp3.video": {minVersion: "0.1", installs: 74}, + "jid1-e7w0SHT82Gv9qA@jetpack": {minVersion: "1.2", installs: 74}, + "NewTabTVCool-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 74}, + "{E173B749-DB5B-4fd2-BA0E-94ECEA0CA55B}": {minVersion: "7.4.1-signed", installs: 73}, + "{9BAE5926-8513-417d-8E47-774955A7C60D}": {minVersion: "1.1.1d.1-signed.1-signed", installs: 73}, + "{3cc6c6ba-654c-417e-a8af-6997ac388ae1}": {minVersion: "49", installs: 72}, + "{daf44bf7-a45e-4450-979c-91cf07434c3d}": {minVersion: "2.0.5", installs: 72}, + "{dbac9680-d559-4cd4-9765-059879e8c467}": {minVersion: "5.0.5", installs: 72}, + "application@recettes.net": {minVersion: "4.5.0", installs: 72}, + "idapluginff@westbyte.com": {minVersion: "1.5.9", installs: 71}, + "imgflashblocker@shimon.chohen": {minVersion: "0.7.1-signed.1-signed", installs: 71}, + "inspector@mozilla.org": {minVersion: "2.0.16.1-signed", installs: 71}, + "jid1-ReWlW1efOwaQJQ@jetpack": {minVersion: "1.1.2", installs: 71}, + "youtubedownloader@trafficterminal.com": {minVersion: "1.0.1.1-signed.1-signed", installs: 71}, + "FavIconReloader@mozilla.org": {minVersion: "0.8.1-signed", installs: 70}, + "_2bMembers_@www.bettercareersearch.com": {minVersion: "7.38.8.45828", installs: 70}, + "{5e594888-3e8e-47da-b2c6-b0b545112f84}": {minVersion: "1.3.18", installs: 70}, + "@greatdealzu": {minVersion: "0.0.3", installs: 70}, + "86ffxtbr@download.yourvideochat.com": {minVersion: "7.36.8.15938", installs: 70}, + "google@hitachi.com": {minVersion: "0.3.1-signed.1-signed", installs: 70}, + "{6e84150a-d526-41f1-a480-a67d3fed910d}": {minVersion: "1.5.6.1-signed.1-signed", installs: 69}, + "firepicker@thedarkone": {minVersion: "1.4.3.1-signed.1-signed", installs: 69}, + "jid0-AocRXUCRsLTCYvn6bgJERnwfuqw@jetpack": {minVersion: "2.8.3.1-signed.1-signed", installs: 69}, + "nortonsecurity@symantec.com": {minVersion: "7.2.0f90", installs: 69}, + "{ef4e370e-d9f0-4e00-b93e-a4f274cfdd5a}": {minVersion: "1.4.10.1-signed", installs: 68}, + "{d4e0dc9c-c356-438e-afbe-dca439f4399d}": {minVersion: "49.1", installs: 68}, + "{E6C93316-271E-4b3d-8D7E-FE11B4350AEB}": {minVersion: "2.1.25.1-signed.1-signed", installs: 68}, + "{fa8476cf-a98c-4e08-99b4-65a69cb4b7d4}": {minVersion: "1.7.6.1", installs: 68}, + "simplesiteblocker@example.com": {minVersion: "1.1.1-signed.1-signed", installs: 68}, + "_fpMembers_@free.passwordlogic.com": {minVersion: "7.102.10.4853", installs: 67}, + "{6e764c17-863a-450f-bdd0-6772bd5aaa18}": {minVersion: "1.0.3.1-signed.1-signed", installs: 67}, + "adbeaver@adbeaver.org": {minVersion: "0.7.2.9", installs: 67}, + "application2@allo-pages.fr": {minVersion: "4.5.0", installs: 67}, + "arf3@getcartt.com": {minVersion: "1.2.3", installs: 67}, + "clearcache@michel.de.almeida": {minVersion: "2.0.1.1-signed.1-signed", installs: 67}, + "fbmessengerpanel@alejandrobrizuela.com.ar": {minVersion: "1.0.3.1-signed.1-signed", installs: 67}, + "tilt@mozilla.com": {minVersion: "1.0.1.1-signed.1-signed", installs: 67}, + "toolbar_AVIRA-V7@apn.ask.com": {minVersion: "127.25", installs: 67}, + "{524B8EF8-C312-11DB-8039-536F56D89593}": {minVersion: "4.91.0.0", installs: 66}, + "{9d1f059c-cada-4111-9696-41a62d64e3ba}": {minVersion: "0.17.0.1", installs: 66}, + "{B068AC18-0121-4e67-9A7E-6386F93F4F7A}": {minVersion: "2.4", installs: 66}, + "@lottadealsun": {minVersion: "0.0.1", installs: 66}, + "@thebestyoutubedownloader": {minVersion: "1.0.0.7", installs: 66}, + "TopSocialTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 66}, + "{11483926-db67-4190-91b1-ef20fcec5f33}": {minVersion: "0.4.9.1", installs: 65}, + "{8AA36F4F-6DC7-4c06-77AF-5035170634FE}": {minVersion: "2016.9.16", installs: 65}, + "dam@tensons.com": {minVersion: "5.0.7", installs: 65}, + "jid1-D7momAzRw417Ag@jetpack": {minVersion: "4.5.13", installs: 65}, + "support@videoadd.ru": {minVersion: "2.8.1.1-signed.1-signed", installs: 65}, + "{95322c08-05ff-4f3c-85fd-8ceb821988dd}": {minVersion: "49", installs: 64}, + "AllMyTube@Wondershare.com": {minVersion: "4.9.1", installs: 64}, + "azan-times@hamid.net": {minVersion: "1.2.3.1-signed.1-signed", installs: 64}, + "check-compatibility@dactyl.googlecode.com": {minVersion: "1.3.1-signed.1-signed", installs: 64}, + "ifamebook@stormvision.it": {minVersion: "4.03.1-signed", installs: 64}, + "jid1-vRJA7N8VwBoiXw@jetpack": {minVersion: "1.1.1.1-signed", installs: 64}, + "{04426594-bce6-4705-b811-bcdba2fd9c7b}": {minVersion: "1.7.1-signed.1-signed", installs: 63}, + "{f3f219f9-cbce-467e-b8fe-6e076d29665c}": {minVersion: "50", installs: 63}, + "fireforce@scrt.ch": {minVersion: "2.2.1-signed.1-signed", installs: 63}, + "FunkyMediaTab-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 63}, + "TopTabTV-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 63}, + "{018f3160-1a6f-4650-84fd-aad8c13609c8}": {minVersion: "0.1.1-signed.1-signed", installs: 62}, + "{2e710e6b-5e9d-44ba-8f4e-09a040978b49}": {minVersion: "1.7", installs: 62}, + "{c1970c0d-dbe6-4d91-804f-c9c0de643a57}": {minVersion: "1.3.2.13.1-signed.1-signed", installs: 62}, + "{c9b4529a-eeba-4e48-976e-f3d3f9026e04}": {minVersion: "1.1.1-signed.1-signed", installs: 62}, + "{df4e4df5-5cb7-46b0-9aef-6c784c3249f8}": {minVersion: "1.3.0.1-signed.1-signed", installs: 62}, + "@stremio": {minVersion: "1.0.2", installs: 62}, + "application@les-pages.com": {minVersion: "4.4.0", installs: 62}, + "ffvkontaktemusic@chupakabr.ru": {minVersion: "2.2.1-signed.1-signed", installs: 62}, + "firefinder@robertnyman.com": {minVersion: "1.4.1-signed.1-signed", installs: 62}, + "formhistory@yahoo.com": {minVersion: "1.4.0.6", installs: 62}, + "fxclickonce@rushyo.com": {minVersion: "0.1.1-signed.1-signed", installs: 62}, + "gmail@borsosfisoft.com": {minVersion: "1.0.1.1-signed.1-signed", installs: 62}, + "HighlightedTextToFile@bobbyrne01.org": {minVersion: "2.7.1", installs: 62}, + "jid1-n85lxPv1NAWVTQ@jetpack": {minVersion: "0.96.1.1-signed", installs: 62}, + "ramback@pavlov.net": {minVersion: "1.0.1-signed.1-signed", installs: 62}, + "VacuumPlacesImproved@lultimouomo-gmail.com": {minVersion: "1.2.1-signed.1-signed", installs: 62}, + "@News": {minVersion: "0.2.0", installs: 61}, + "{45d8ff86-d909-11db-9705-005056c00008}": {minVersion: "1.3.4.8", installs: 61}, + "{686fc9c5-c339-43db-b93a-5181a217f9a6}": {minVersion: "1.11", installs: 61}, + "{ea2b95c2-9be8-48ed-bdd1-5fcd2ad0ff99}": {minVersion: "0.3.8.1.1-signed.1-signed", installs: 61}, + "@chomikuj": {minVersion: "1.2.0", installs: 61}, + "avg@wtu3": {minVersion: "3.7.0.0", installs: 61}, + "jid1-f7dnBeTj8ElpWQ@jetpack": {minVersion: "1.34.1-signed.1-signed", installs: 61}, + "jid1-OY8Xu5BsKZQa6A@jetpack": {minVersion: "2.0.21", installs: 61}, + "jid1-u9RbFp9JcoEGGw@jetpack": {minVersion: "1.2.2.1-signed.1-signed", installs: 61}, + "plugin@okta.com": {minVersion: "5.8.0", installs: 61}, + "showpassword@pratikpoddar": {minVersion: "1.7.1-signed.1-signed", installs: 61}, + "IGF.F3@igufei.com": {minVersion: "3.2.11", installs: 60}, + "{12b6fdcd-4423-4276-82a3-73fdbff5f7e4}": {minVersion: "50", installs: 60}, + "{8F6A6FD9-0619-459f-B9D0-81DE065D4E21}": {minVersion: "1.13", installs: 60}, + "jid1-mW7iuA66Ny8Ziw@jetpack": {minVersion: "0.9.1-signed.1-signed", installs: 60}, + "nishan.naseer.googimagesearch@gmail.com": {minVersion: "0.5.1-signed.1-signed", installs: 60}, + "quicksearch@yandex.ru": {minVersion: "1.0.13", installs: 60}, + "{902D2C4A-457A-4EF9-AD43-7014562929FF}": {minVersion: "0.6.4", installs: 59}, + "@yset": {minVersion: "0.0.10", installs: 59}, + "csscoverage@spaghetticoder.org": {minVersion: "0.3.4.1-signed.1-signed", installs: 59}, + "dgnria2@nuance.com": {minVersion: "15.00.000.058", installs: 59}, + "firequery@binaryage.com": {minVersion: "2.0.4", installs: 59}, + "IBM-cck@firefox-extensions.ibm.com": {minVersion: "2.3.0", installs: 59}, + "trackmenot@mrl.nyu.edu": {minVersion: "0.9.2", installs: 59}, + "_chMembers_@free.discoverancestry.com": {minVersion: "7.102.10.3818", installs: 58}, + "{338e0b96-2285-4424-b4c8-e25560750fa3}": {minVersion: "3.1-signed.1-signed", installs: 58}, + "{8b5bea8c-6194-4c7c-a440-d5ca181480c3}": {minVersion: "1.500.000.11", installs: 58}, + "{e30e9060-21d5-11e3-8224-0800200c9a66}": {minVersion: "1.2.12", installs: 58}, + "LDshowpicture_plashcor@gmail.com": {minVersion: "3.2", installs: 58}, + "open.about.permissions@jasnapaka.com": {minVersion: "1.2.1-signed.1-signed", installs: 58}, + "sqlime@security.compass": {minVersion: "0.4.7.1-signed.1-signed", installs: 58}, + "@jetpack-easy-turism2": {minVersion: "7.1.0", installs: 57}, + "check4change-owner@mozdev.org": {minVersion: "1.9.8.1", installs: 57}, + "jid1-SDFC9fEAZRW7ab@jetpack": {minVersion: "0.1.3.1-signed.1-signed", installs: 57}, + "linkgopher@oooninja.com": {minVersion: "1.3.3.1-signed.1-signed", installs: 57}, + "pixelperfectplugin@openhouseconcepts.com": {minVersion: "2.0.14", installs: 57}, + "YoutubeDownloader@huangho.net76.net": {minVersion: "1.6.5.1-signed.1-signed", installs: 57}, + "lwthemes-manager@loucypher": {minVersion: "0.2.1-signed.1-let-fixed.1-signed", installs: 56}, + "_eiMembers_@www.100sofrecipes.com": {minVersion: "7.102.10.3580", installs: 56}, + "{068c594c-1a69-4f51-888d-1e231eac59a3}": {minVersion: "1", installs: 56}, + "{139C4B80-60ED-11E4-80EC-84041E5D46B0}": {minVersion: "1.3", installs: 56}, + "{4c7097f7-08f2-4ef2-9b9f-f95fa4cbb064}": {minVersion: "1.1", installs: 56}, + "{776f38cb-6255-4b92-b5cf-e5c71ff2b688}": {minVersion: "1.6", installs: 56}, + "{79c50f9a-2ffe-4ee0-8a37-fae4f5dacd4f}": {minVersion: "5.1.3", installs: 56}, + "{8BCA0E8A-E57B-425b-A05B-CD3868EB577E}": {minVersion: "1.4.1-signed.1-signed", installs: 56}, + "easycopypaste@everhelper.me": {minVersion: "1.1.0.1-signed.1-signed", installs: 56}, + "NoiaFoxoption@davidvincent.tld": {minVersion: "3.0.2.1-signed", installs: 56}, + "r2d2b2g@mozilla.org": {minVersion: "4.0.4.1-signed", installs: 56}, + "TFToolbarX@torrent-finder": {minVersion: "1.3.1.1-signed.1-signed", installs: 56}, + "{E4091D66-127C-11DB-903A-DE80D2EFDFE8}": {minVersion: "1.6.5.5.1-signed.1-signed", installs: 55}, + "downintab@max.max": {minVersion: "1.00.1-signed.1-signed", installs: 55}, + "flv2mp3@hotger.com": {minVersion: "2.3.2-signed", installs: 55}, + "ISVCU@iSkysoft.com": {minVersion: "5.1.0", installs: 55}, + "jid1-n5ARdBzHkUEdAA@jetpack": {minVersion: "3.8.7", installs: 55}, + "rpnetdownloadhelper@gmail.com": {minVersion: "3.0.1-signed.1-signed", installs: 55}, + "shpassword@shpassword.fr": {minVersion: "0.3.1-signed.1-signed", installs: 55}, + "snt@simplenewtab.com": {minVersion: "1.3", installs: 55}, + "admin@djamol.com": {minVersion: "4.31.1-signed.1-signed", installs: 54}, + "{22870005-adef-4c9d-ae36-d0e1f2f27e5a}": {minVersion: "0.4.0.9.1.1-signed.1-signed", installs: 54}, + "{DBBB3167-6E81-400f-BBFD-BD8921726F52}": {minVersion: "7125.2016.0115.2213", installs: 54}, + "{e4f94d1e-2f53-401e-8885-681602c0ddd8}": {minVersion: "1.0.1-signed.1-signed", installs: 54}, + "{FBF6D7FB-F305-4445-BB3D-FEF66579A033}": {minVersion: "6", installs: 54}, + "5aa55fd5-6e61-4896-b186-fdc6f298ec92@mozilla": {minVersion: "0.1.2.1-signed", installs: 54}, + "fireml@sirma.bg": {minVersion: "1.1.11.1-signed.1-signed", installs: 54}, + "info@priceblink.com": {minVersion: "4.8", installs: 54}, + "jid0-f82gosWvE8oeGQt6WDCGRF1Dy7Q@jetpack": {minVersion: "1.0.003", installs: 54}, + "jid0-hyjN250ZzTOOX3evFwwAQBxE4ik@jetpack": {minVersion: "6.0.1-signed.1-signed", installs: 54}, + "restart@restart.org": {minVersion: "0.5.1-signed.1-signed", installs: 54}, + "webmaster@keep-tube.com": {minVersion: "1.2.1-signed.1-signed", installs: 54}, + "eliteproxyswitcher@my-proxy.com": {minVersion: "1.2.0.2.1-signed.1-signed", installs: 53}, + "foxfilter@inspiredeffect.net": {minVersion: "7.7.1-signed.1-signed", installs: 53}, + "searchprivacy@searchprivacy.co": {minVersion: "1.15", installs: 53}, + "SignPlugin@pekao.pl": {minVersion: "1.4.0.73", installs: 53}, + "{15fe27f3-e5ab-2d59-4c5c-dadc7945bdbd}": {minVersion: "2.1.1.1-signed.1-signed", installs: 52}, + "ipfuck@p4ul.info": {minVersion: "1.2.1.1-signed.1-signed", installs: 52}, + "jyboy.yy@gmail.com": {minVersion: "1.0.4.1-signed.1-signed", installs: 52}, + "MySafeTabs-the-extension1@mozilla.com": {minVersion: "0.1.9", installs: 52}, + "saiful.neo@gmail.com": {minVersion: "3.0.1-signed.1-signed", installs: 52}, + "sendtokindle@amazon.com": {minVersion: "1.0.2.76", installs: 52}, + "smile1Button@amazon.com": {minVersion: "1.0.1-signed.1-signed", installs: 52}, + "whodeletedme@deleted.io": {minVersion: "0.3.3", installs: 52}, + "{C0CB8BA3-6C1B-47e8-A6AB-1FAB889562D9}": {minVersion: "0.7.6", installs: 51}, + "@irctctatkal": {minVersion: "2.0.0", installs: 51}, + "antgroup@antdownloadmanager.com": {minVersion: "0.1.7", installs: 51}, + "downloadplan@firefoxmania.uci.cu": {minVersion: "1.3.1-signed.1-signed", installs: 51}, + "jid1-AoXeeOB4j7kFdA@jetpack": {minVersion: "8.1", installs: 51}, + "memoryrestart@teamextension.com": {minVersion: "1.18.1-signed.1-signed", installs: 51}, + "multifox-toolbar-button@rbaldwin": {minVersion: "4.28.1-signed.1-signed", installs: 51}, + "soaclient@santoso": {minVersion: "0.2.1-signed.1-signed", installs: 51}, + "speeddns@gmail.com": {minVersion: "0.2.1-signed.1-signed", installs: 51}, + "windowandtablimiter@weintraut.net": {minVersion: "4.28.1-signed.1-signed", installs: 51}, + "@Recipes": {minVersion: "0.2.0", installs: 50}, + "{e6a9a96e-4a08-4719-b9bd-0e91c35aaabc}": {minVersion: "1.3.1.1-signed.1-signed", installs: 50}, + "autopager@mozilla.org": {minVersion: "0.8.0.10.1-signed.1-signed", installs: 50}, + "btpersonas@brandthunder.com": {minVersion: "2.0.4.7", installs: 50}, + "gdrivepanel@alejandrobrizuela.com.ar": {minVersion: "1.0.2.1-signed.1-signed", installs: 50}, + "jid1-m3kqTBs1zKXXaA@jetpack": {minVersion: "0.2.6.1-signed.1-signed", installs: 50}, + "qqmail_plugin_for_firefox@tencent.com": {minVersion: "1.0.0.22", installs: 50}, + "savefileto@mozdev.org": {minVersion: "2.5.5", installs: 50}, + "seodoctor@prelovac.com": {minVersion: "1.6.5.1-signed.1-signed", installs: 50}, + "support@todoist.com": {minVersion: "4.0.5", installs: 50}, + "toolbar_TeoMediaTB@apn.ask.com": {minVersion: "135.3", installs: 50}, + "txftn@tencent.com": {minVersion: "1.0.0.7", installs: 50}, +}; + +// ================== END OF LIST FOR 51 ====================== + +// We use these named policies to correlate the telemetry +// data with them, in order to understand how each set +// is behaving in the wild. +const RolloutPolicy = { + // Used during 48 Beta cycle + "2a": { addons: set2, webextensions: true }, + "2b": { addons: set2, webextensions: false }, + + // Set agreed for Release 49 + "49a": { addons: set49Release, webextensions: true }, + "49b": { addons: set49Release, webextensions: false }, + + // Smaller set that can be used for Release 49 + "49limiteda": { addons: set49PaneOnly, webextensions: true }, + "49limitedb": { addons: set49PaneOnly, webextensions: false }, + + // Beta testing on 50 + "50allmpc": { addons: [], webextensions: true, mpc: true }, + + // Beta testing on 51 + "51alladdons": { addons: [], webextensions: true, alladdons: true }, + + // 51 release + "51set1": { addonsv2: set51Release, installs: 50, webextensions: true, mpc: true }, + "51set2": { addonsv2: set51Release, installs: 100, webextensions: true, mpc: true }, + "51set3": { addonsv2: set51Release, installs: 300, webextensions: true, mpc: true }, + "51set4": { addonsv2: set51Release, installs: 1000, webextensions: true, mpc: true }, + + // ESR + "esrA": { addons: [], mpc: true, webextensions: true }, + "esrB": { addons: [], mpc: true, webextensions: false }, + "esrC": { addons: [], mpc: false, webextensions: true }, + + "xpcshell-test": { addons: [ADDONS.test1, ADDONS.test2], webextensions: false }, +}; + +Object.defineProperty(this, "isAddonPartOfE10SRollout", { + configurable: false, + enumerable: false, + writable: false, + value: function isAddonPartOfE10SRollout(aAddon) { + let blocklist = Preferences.get(PREF_E10S_ADDON_BLOCKLIST, ""); + let policyId = Preferences.get(PREF_E10S_ADDON_POLICY, ""); + + if (!policyId || !RolloutPolicy.hasOwnProperty(policyId)) { + return false; + } + + if (blocklist && blocklist.indexOf(aAddon.id) > -1) { + return false; + } + + let policy = RolloutPolicy[policyId]; + + if (aAddon.mpcOptedOut == true) { + return false; + } + + if (policy.alladdons) { + return true; + } + + if (policy.webextensions && aAddon.type == "webextension") { + return true; + } + + if (policy.mpc && aAddon.multiprocessCompatible) { + return true; + } + + if (policy.addonsv2) { + if (aAddon.id in policy.addonsv2) { + let rolloutAddon = policy.addonsv2[aAddon.id]; + + if (rolloutAddon.installs >= policy.installs && + Services.vc.compare(aAddon.version, rolloutAddon.minVersion) >= 0) { + return true; + } + } + return false; + } + + for (let rolloutAddon of policy.addons) { + if (aAddon.id == rolloutAddon.id && + Services.vc.compare(aAddon.version, rolloutAddon.minVersion) >= 0) { + return true; + } + } + + return false; + }, +}); diff --git a/toolkit/mozapps/extensions/internal/GMPProvider.jsm b/toolkit/mozapps/extensions/internal/GMPProvider.jsm new file mode 100644 index 0000000000..9bb34a7af6 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/GMPProvider.jsm @@ -0,0 +1,699 @@ +/* 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 Cu = Components.utils; + +this.EXPORTED_SYMBOLS = []; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/AddonManager.jsm"); +/* globals AddonManagerPrivate*/ +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/Preferences.jsm"); +Cu.import("resource://gre/modules/osfile.jsm"); +/* globals OS*/ +Cu.import("resource://gre/modules/Log.jsm"); +Cu.import("resource://gre/modules/Task.jsm"); +Cu.import("resource://gre/modules/GMPUtils.jsm"); +/* globals EME_ADOBE_ID, GMP_PLUGIN_IDS, GMPPrefs, GMPUtils, OPEN_H264_ID, WIDEVINE_ID */ +Cu.import("resource://gre/modules/AppConstants.jsm"); +Cu.import("resource://gre/modules/UpdateUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter( + this, "GMPInstallManager", "resource://gre/modules/GMPInstallManager.jsm"); +XPCOMUtils.defineLazyModuleGetter( + this, "setTimeout", "resource://gre/modules/Timer.jsm"); + +const URI_EXTENSION_STRINGS = "chrome://mozapps/locale/extensions/extensions.properties"; +const STRING_TYPE_NAME = "type.%ID%.name"; + +const SEC_IN_A_DAY = 24 * 60 * 60; +// How long to wait after a user enabled EME before attempting to download CDMs. +const GMP_CHECK_DELAY = 10 * 1000; // milliseconds + +const NS_GRE_DIR = "GreD"; +const CLEARKEY_PLUGIN_ID = "gmp-clearkey"; +const CLEARKEY_VERSION = "0.1"; + +const GMP_LICENSE_INFO = "gmp_license_info"; +const GMP_PRIVACY_INFO = "gmp_privacy_info"; +const GMP_LEARN_MORE = "learn_more_label"; + +const GMP_PLUGINS = [ + { + id: OPEN_H264_ID, + name: "openH264_name", + description: "openH264_description2", + // The following licenseURL is part of an awful hack to include the OpenH264 + // license without having bug 624602 fixed yet, and intentionally ignores + // localisation. + licenseURL: "chrome://mozapps/content/extensions/OpenH264-license.txt", + homepageURL: "http://www.openh264.org/", + optionsURL: "chrome://mozapps/content/extensions/gmpPrefs.xul", + }, + { + id: EME_ADOBE_ID, + name: "eme-adobe_name", + description: "eme-adobe_description", + // The following learnMoreURL is another hack to be able to support a SUMO page for this + // feature. + get learnMoreURL() { + return Services.urlFormatter.formatURLPref("app.support.baseURL") + "drm-content"; + }, + licenseURL: "http://help.adobe.com/en_US/primetime/drm/HTML5_CDM_EULA/index.html", + homepageURL: "http://help.adobe.com/en_US/primetime/drm/HTML5_CDM", + optionsURL: "chrome://mozapps/content/extensions/gmpPrefs.xul", + isEME: true, + }, + { + id: WIDEVINE_ID, + name: "widevine_description", + // Describe the purpose of both CDMs in the same way. + description: "eme-adobe_description", + licenseURL: "https://www.google.com/policies/privacy/", + homepageURL: "https://www.widevine.com/", + optionsURL: "chrome://mozapps/content/extensions/gmpPrefs.xul", + isEME: true + }]; +XPCOMUtils.defineConstant(this, "GMP_PLUGINS", GMP_PLUGINS); + +XPCOMUtils.defineLazyGetter(this, "pluginsBundle", + () => Services.strings.createBundle("chrome://global/locale/plugins.properties")); +XPCOMUtils.defineLazyGetter(this, "gmpService", + () => Cc["@mozilla.org/gecko-media-plugin-service;1"].getService(Ci.mozIGeckoMediaPluginChromeService)); + +var messageManager = Cc["@mozilla.org/globalmessagemanager;1"] + .getService(Ci.nsIMessageListenerManager); + +var gLogger; +var gLogAppenderDump = null; + +function configureLogging() { + if (!gLogger) { + gLogger = Log.repository.getLogger("Toolkit.GMP"); + gLogger.addAppender(new Log.ConsoleAppender(new Log.BasicFormatter())); + } + gLogger.level = GMPPrefs.get(GMPPrefs.KEY_LOGGING_LEVEL, Log.Level.Warn); + + let logDumping = GMPPrefs.get(GMPPrefs.KEY_LOGGING_DUMP, false); + if (logDumping != !!gLogAppenderDump) { + if (logDumping) { + gLogAppenderDump = new Log.DumpAppender(new Log.BasicFormatter()); + gLogger.addAppender(gLogAppenderDump); + } else { + gLogger.removeAppender(gLogAppenderDump); + gLogAppenderDump = null; + } + } +} + + + +/** + * The GMPWrapper provides the info for the various GMP plugins to public + * callers through the API. + */ +function GMPWrapper(aPluginInfo) { + this._plugin = aPluginInfo; + this._log = + Log.repository.getLoggerWithMessagePrefix("Toolkit.GMP", + "GMPWrapper(" + + this._plugin.id + ") "); + Preferences.observe(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_ENABLED, + this._plugin.id), + this.onPrefEnabledChanged, this); + Preferences.observe(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_VERSION, + this._plugin.id), + this.onPrefVersionChanged, this); + if (this._plugin.isEME) { + Preferences.observe(GMPPrefs.KEY_EME_ENABLED, + this.onPrefEMEGlobalEnabledChanged, this); + messageManager.addMessageListener("EMEVideo:ContentMediaKeysRequest", this); + } +} + +GMPWrapper.prototype = { + // An active task that checks for plugin updates and installs them. + _updateTask: null, + _gmpPath: null, + _isUpdateCheckPending: false, + + optionsType: AddonManager.OPTIONS_TYPE_INLINE, + get optionsURL() { return this._plugin.optionsURL; }, + + set gmpPath(aPath) { this._gmpPath = aPath; }, + get gmpPath() { + if (!this._gmpPath && this.isInstalled) { + this._gmpPath = OS.Path.join(OS.Constants.Path.profileDir, + this._plugin.id, + GMPPrefs.get(GMPPrefs.KEY_PLUGIN_VERSION, + null, this._plugin.id)); + } + return this._gmpPath; + }, + + get id() { return this._plugin.id; }, + get type() { return "plugin"; }, + get isGMPlugin() { return true; }, + get name() { return this._plugin.name; }, + get creator() { return null; }, + get homepageURL() { return this._plugin.homepageURL; }, + + get description() { return this._plugin.description; }, + get fullDescription() { return this._plugin.fullDescription; }, + + get version() { return GMPPrefs.get(GMPPrefs.KEY_PLUGIN_VERSION, null, + this._plugin.id); }, + + get isActive() { + return !this.appDisabled && + !this.userDisabled && + !GMPUtils.isPluginHidden(this._plugin); + }, + get appDisabled() { + if (this._plugin.isEME && !GMPPrefs.get(GMPPrefs.KEY_EME_ENABLED, true)) { + // If "media.eme.enabled" is false, all EME plugins are disabled. + return true; + } + return false; + }, + + get userDisabled() { + return !GMPPrefs.get(GMPPrefs.KEY_PLUGIN_ENABLED, true, this._plugin.id); + }, + set userDisabled(aVal) { GMPPrefs.set(GMPPrefs.KEY_PLUGIN_ENABLED, + aVal === false, + this._plugin.id); }, + + get blocklistState() { return Ci.nsIBlocklistService.STATE_NOT_BLOCKED; }, + get size() { return 0; }, + get scope() { return AddonManager.SCOPE_APPLICATION; }, + get pendingOperations() { return AddonManager.PENDING_NONE; }, + + get operationsRequiringRestart() { return AddonManager.OP_NEEDS_RESTART_NONE }, + + get permissions() { + let permissions = 0; + if (!this.appDisabled) { + permissions |= AddonManager.PERM_CAN_UPGRADE; + permissions |= this.userDisabled ? AddonManager.PERM_CAN_ENABLE : + AddonManager.PERM_CAN_DISABLE; + } + return permissions; + }, + + get updateDate() { + let time = Number(GMPPrefs.get(GMPPrefs.KEY_PLUGIN_LAST_UPDATE, null, + this._plugin.id)); + if (!isNaN(time) && this.isInstalled) { + return new Date(time * 1000) + } + return null; + }, + + get isCompatible() { + return true; + }, + + get isPlatformCompatible() { + return true; + }, + + get providesUpdatesSecurely() { + return true; + }, + + get foreignInstall() { + return false; + }, + + isCompatibleWith: function(aAppVersion, aPlatformVersion) { + return true; + }, + + get applyBackgroundUpdates() { + if (!GMPPrefs.isSet(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, this._plugin.id)) { + return AddonManager.AUTOUPDATE_DEFAULT; + } + + return GMPPrefs.get(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, true, this._plugin.id) ? + AddonManager.AUTOUPDATE_ENABLE : AddonManager.AUTOUPDATE_DISABLE; + }, + + set applyBackgroundUpdates(aVal) { + if (aVal == AddonManager.AUTOUPDATE_DEFAULT) { + GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, this._plugin.id); + } else if (aVal == AddonManager.AUTOUPDATE_ENABLE) { + GMPPrefs.set(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, true, this._plugin.id); + } else if (aVal == AddonManager.AUTOUPDATE_DISABLE) { + GMPPrefs.set(GMPPrefs.KEY_PLUGIN_AUTOUPDATE, false, this._plugin.id); + } + }, + + findUpdates: function(aListener, aReason, aAppVersion, aPlatformVersion) { + this._log.trace("findUpdates() - " + this._plugin.id + " - reason=" + + aReason); + + AddonManagerPrivate.callNoUpdateListeners(this, aListener); + + if (aReason === AddonManager.UPDATE_WHEN_PERIODIC_UPDATE) { + if (!AddonManager.shouldAutoUpdate(this)) { + this._log.trace("findUpdates() - " + this._plugin.id + + " - no autoupdate"); + return Promise.resolve(false); + } + + let secSinceLastCheck = + Date.now() / 1000 - Preferences.get(GMPPrefs.KEY_UPDATE_LAST_CHECK, 0); + if (secSinceLastCheck <= SEC_IN_A_DAY) { + this._log.trace("findUpdates() - " + this._plugin.id + + " - last check was less then a day ago"); + return Promise.resolve(false); + } + } else if (aReason !== AddonManager.UPDATE_WHEN_USER_REQUESTED) { + this._log.trace("findUpdates() - " + this._plugin.id + + " - the given reason to update is not supported"); + return Promise.resolve(false); + } + + if (this._updateTask !== null) { + this._log.trace("findUpdates() - " + this._plugin.id + + " - update task already running"); + return this._updateTask; + } + + this._updateTask = Task.spawn(function*() { + this._log.trace("findUpdates() - updateTask"); + try { + let installManager = new GMPInstallManager(); + let res = yield installManager.checkForAddons(); + let update = res.gmpAddons.find(addon => addon.id === this._plugin.id); + if (update && update.isValid && !update.isInstalled) { + this._log.trace("findUpdates() - found update for " + + this._plugin.id + ", installing"); + yield installManager.installAddon(update); + } else { + this._log.trace("findUpdates() - no updates for " + this._plugin.id); + } + this._log.info("findUpdates() - updateTask succeeded for " + + this._plugin.id); + } catch (e) { + this._log.error("findUpdates() - updateTask for " + this._plugin.id + + " threw", e); + throw e; + } finally { + this._updateTask = null; + return true; + } + }.bind(this)); + + return this._updateTask; + }, + + get pluginMimeTypes() { return []; }, + get pluginLibraries() { + if (this.isInstalled) { + let path = this.version; + return [path]; + } + return []; + }, + get pluginFullpath() { + if (this.isInstalled) { + let path = OS.Path.join(OS.Constants.Path.profileDir, + this._plugin.id, + this.version); + return [path]; + } + return []; + }, + + get isInstalled() { + return this.version && this.version.length > 0; + }, + + _handleEnabledChanged: function() { + this._log.info("_handleEnabledChanged() id=" + + this._plugin.id + " isActive=" + this.isActive); + + AddonManagerPrivate.callAddonListeners(this.isActive ? + "onEnabling" : "onDisabling", + this, false); + if (this._gmpPath) { + if (this.isActive) { + this._log.info("onPrefEnabledChanged() - adding gmp directory " + + this._gmpPath); + gmpService.addPluginDirectory(this._gmpPath); + } else { + this._log.info("onPrefEnabledChanged() - removing gmp directory " + + this._gmpPath); + gmpService.removePluginDirectory(this._gmpPath); + } + } + AddonManagerPrivate.callAddonListeners(this.isActive ? + "onEnabled" : "onDisabled", + this); + }, + + onPrefEMEGlobalEnabledChanged: function() { + this._log.info("onPrefEMEGlobalEnabledChanged() id=" + this._plugin.id + + " appDisabled=" + this.appDisabled + " isActive=" + this.isActive + + " hidden=" + GMPUtils.isPluginHidden(this._plugin)); + + AddonManagerPrivate.callAddonListeners("onPropertyChanged", this, + ["appDisabled"]); + // If EME or the GMP itself are disabled, uninstall the GMP. + // Otherwise, check for updates, so we download and install the GMP. + if (this.appDisabled) { + this.uninstallPlugin(); + } else if (!GMPUtils.isPluginHidden(this._plugin)) { + AddonManagerPrivate.callInstallListeners("onExternalInstall", null, this, + null, false); + AddonManagerPrivate.callAddonListeners("onInstalling", this, false); + AddonManagerPrivate.callAddonListeners("onInstalled", this); + this.checkForUpdates(GMP_CHECK_DELAY); + } + if (!this.userDisabled) { + this._handleEnabledChanged(); + } + }, + + checkForUpdates: function(delay) { + if (this._isUpdateCheckPending) { + return; + } + this._isUpdateCheckPending = true; + GMPPrefs.reset(GMPPrefs.KEY_UPDATE_LAST_CHECK, null); + // Delay this in case the user changes his mind and doesn't want to + // enable EME after all. + setTimeout(() => { + if (!this.appDisabled) { + let gmpInstallManager = new GMPInstallManager(); + // We don't really care about the results, if someone is interested + // they can check the log. + gmpInstallManager.simpleCheckAndInstall().then(null, () => {}); + } + this._isUpdateCheckPending = false; + }, delay); + }, + + receiveMessage: function({target: browser, data: data}) { + this._log.trace("receiveMessage() data=" + data); + let parsedData; + try { + parsedData = JSON.parse(data); + } catch (ex) { + this._log.error("Malformed EME video message with data: " + data); + return; + } + let {status: status, keySystem: keySystem} = parsedData; + if (status == "cdm-not-installed") { + this.checkForUpdates(0); + } + }, + + onPrefEnabledChanged: function() { + if (!this._plugin.isEME || !this.appDisabled) { + this._handleEnabledChanged(); + } + }, + + onPrefVersionChanged: function() { + AddonManagerPrivate.callAddonListeners("onUninstalling", this, false); + if (this._gmpPath) { + this._log.info("onPrefVersionChanged() - unregistering gmp directory " + + this._gmpPath); + gmpService.removeAndDeletePluginDirectory(this._gmpPath, true /* can defer */); + } + AddonManagerPrivate.callAddonListeners("onUninstalled", this); + + AddonManagerPrivate.callInstallListeners("onExternalInstall", null, this, + null, false); + AddonManagerPrivate.callAddonListeners("onInstalling", this, false); + this._gmpPath = null; + if (this.isInstalled) { + this._gmpPath = OS.Path.join(OS.Constants.Path.profileDir, + this._plugin.id, + GMPPrefs.get(GMPPrefs.KEY_PLUGIN_VERSION, + null, this._plugin.id)); + } + if (this._gmpPath && this.isActive) { + this._log.info("onPrefVersionChanged() - registering gmp directory " + + this._gmpPath); + gmpService.addPluginDirectory(this._gmpPath); + } + AddonManagerPrivate.callAddonListeners("onInstalled", this); + }, + + uninstallPlugin: function() { + AddonManagerPrivate.callAddonListeners("onUninstalling", this, false); + if (this.gmpPath) { + this._log.info("uninstallPlugin() - unregistering gmp directory " + + this.gmpPath); + gmpService.removeAndDeletePluginDirectory(this.gmpPath); + } + GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_VERSION, this.id); + GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_ABI, this.id); + GMPPrefs.reset(GMPPrefs.KEY_PLUGIN_LAST_UPDATE, this.id); + AddonManagerPrivate.callAddonListeners("onUninstalled", this); + }, + + shutdown: function() { + Preferences.ignore(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_ENABLED, + this._plugin.id), + this.onPrefEnabledChanged, this); + Preferences.ignore(GMPPrefs.getPrefKey(GMPPrefs.KEY_PLUGIN_VERSION, + this._plugin.id), + this.onPrefVersionChanged, this); + if (this._plugin.isEME) { + Preferences.ignore(GMPPrefs.KEY_EME_ENABLED, + this.onPrefEMEGlobalEnabledChanged, this); + messageManager.removeMessageListener("EMEVideo:ContentMediaKeysRequest", this); + } + return this._updateTask; + }, + + _arePluginFilesOnDisk: function() { + let fileExists = function(aGmpPath, aFileName) { + let f = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + let path = OS.Path.join(aGmpPath, aFileName); + f.initWithPath(path); + return f.exists(); + }; + + let id = this._plugin.id.substring(4); + let libName = AppConstants.DLL_PREFIX + id + AppConstants.DLL_SUFFIX; + let infoName; + if (this._plugin.id == WIDEVINE_ID) { + infoName = "manifest.json"; + } else { + infoName = id + ".info"; + } + + return fileExists(this.gmpPath, libName) && + fileExists(this.gmpPath, infoName) && + (this._plugin.id != EME_ADOBE_ID || fileExists(this.gmpPath, id + ".voucher")); + }, + + validate: function() { + if (!this.isInstalled) { + // Not installed -> Valid. + return { + installed: false, + valid: true + }; + } + + let abi = GMPPrefs.get(GMPPrefs.KEY_PLUGIN_ABI, UpdateUtils.ABI, this._plugin.id); + if (abi != UpdateUtils.ABI) { + // ABI doesn't match. Possibly this is a profile migrated across platforms + // or from 32 -> 64 bit. + return { + installed: true, + mismatchedABI: true, + valid: false + }; + } + + // Installed -> Check if files are missing. + let filesOnDisk = this._arePluginFilesOnDisk(); + return { + installed: true, + valid: filesOnDisk + }; + }, +}; + +var GMPProvider = { + get name() { return "GMPProvider"; }, + + _plugins: null, + + startup: function() { + configureLogging(); + this._log = Log.repository.getLoggerWithMessagePrefix("Toolkit.GMP", + "GMPProvider."); + this.buildPluginList(); + this.ensureProperCDMInstallState(); + + Preferences.observe(GMPPrefs.KEY_LOG_BASE, configureLogging); + + for (let [id, plugin] of this._plugins) { + let wrapper = plugin.wrapper; + let gmpPath = wrapper.gmpPath; + let isEnabled = wrapper.isActive; + this._log.trace("startup - enabled=" + isEnabled + ", gmpPath=" + + gmpPath); + + if (gmpPath && isEnabled) { + let validation = wrapper.validate(); + if (validation.mismatchedABI) { + this._log.info("startup - gmp " + plugin.id + + " mismatched ABI, uninstalling"); + wrapper.uninstallPlugin(); + continue; + } + if (!validation.valid) { + this._log.info("startup - gmp " + plugin.id + + " invalid, uninstalling"); + wrapper.uninstallPlugin(); + continue; + } + this._log.info("startup - adding gmp directory " + gmpPath); + try { + gmpService.addPluginDirectory(gmpPath); + } catch (e) { + if (e.name != 'NS_ERROR_NOT_AVAILABLE') + throw e; + this._log.warn("startup - adding gmp directory failed with " + + e.name + " - sandboxing not available?", e); + } + } + } + + try { + let greDir = Services.dirsvc.get(NS_GRE_DIR, + Ci.nsILocalFile); + let clearkeyPath = OS.Path.join(greDir.path, + CLEARKEY_PLUGIN_ID, + CLEARKEY_VERSION); + this._log.info("startup - adding clearkey CDM directory " + + clearkeyPath); + gmpService.addPluginDirectory(clearkeyPath); + } catch (e) { + this._log.warn("startup - adding clearkey CDM failed", e); + } + }, + + shutdown: function() { + this._log.trace("shutdown"); + Preferences.ignore(GMPPrefs.KEY_LOG_BASE, configureLogging); + + let shutdownTask = Task.spawn(function*() { + this._log.trace("shutdown - shutdownTask"); + let shutdownSucceeded = true; + + for (let plugin of this._plugins.values()) { + try { + yield plugin.wrapper.shutdown(); + } catch (e) { + shutdownSucceeded = false; + } + } + + this._plugins = null; + + if (!shutdownSucceeded) { + throw new Error("Shutdown failed"); + } + }.bind(this)); + + return shutdownTask; + }, + + getAddonByID: function(aId, aCallback) { + if (!this.isEnabled) { + aCallback(null); + return; + } + + let plugin = this._plugins.get(aId); + if (plugin && !GMPUtils.isPluginHidden(plugin)) { + aCallback(plugin.wrapper); + } else { + aCallback(null); + } + }, + + getAddonsByTypes: function(aTypes, aCallback) { + if (!this.isEnabled || + (aTypes && aTypes.indexOf("plugin") < 0)) { + aCallback([]); + return; + } + + let results = Array.from(this._plugins.values()) + .filter(p => !GMPUtils.isPluginHidden(p)) + .map(p => p.wrapper); + + aCallback(results); + }, + + get isEnabled() { + return GMPPrefs.get(GMPPrefs.KEY_PROVIDER_ENABLED, false); + }, + + generateFullDescription: function(aPlugin) { + let rv = []; + for (let [urlProp, labelId] of [["learnMoreURL", GMP_LEARN_MORE], + ["licenseURL", aPlugin.id == WIDEVINE_ID ? + GMP_PRIVACY_INFO : GMP_LICENSE_INFO]]) { + if (aPlugin[urlProp]) { + let label = pluginsBundle.GetStringFromName(labelId); + rv.push(`${label}.`); + } + } + return rv.length ? rv.join("") : undefined; + }, + + buildPluginList: function() { + this._plugins = new Map(); + for (let aPlugin of GMP_PLUGINS) { + let plugin = { + id: aPlugin.id, + name: pluginsBundle.GetStringFromName(aPlugin.name), + description: pluginsBundle.GetStringFromName(aPlugin.description), + homepageURL: aPlugin.homepageURL, + optionsURL: aPlugin.optionsURL, + wrapper: null, + isEME: aPlugin.isEME, + }; + plugin.fullDescription = this.generateFullDescription(aPlugin); + plugin.wrapper = new GMPWrapper(plugin); + this._plugins.set(plugin.id, plugin); + } + }, + + ensureProperCDMInstallState: function() { + if (!GMPPrefs.get(GMPPrefs.KEY_EME_ENABLED, true)) { + for (let [id, plugin] of this._plugins) { + if (plugin.isEME && plugin.wrapper.isInstalled) { + gmpService.addPluginDirectory(plugin.wrapper.gmpPath); + plugin.wrapper.uninstallPlugin(); + } + } + } + }, +}; + +AddonManagerPrivate.registerProvider(GMPProvider, [ + new AddonManagerPrivate.AddonType("plugin", URI_EXTENSION_STRINGS, + STRING_TYPE_NAME, + AddonManager.VIEW_TYPE_LIST, 6000, + AddonManager.TYPE_SUPPORTS_ASK_TO_ACTIVATE) +]); diff --git a/toolkit/mozapps/extensions/internal/LightweightThemeImageOptimizer.jsm b/toolkit/mozapps/extensions/internal/LightweightThemeImageOptimizer.jsm new file mode 100644 index 0000000000..49dfa237fe --- /dev/null +++ b/toolkit/mozapps/extensions/internal/LightweightThemeImageOptimizer.jsm @@ -0,0 +1,180 @@ +/* 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"; + +this.EXPORTED_SYMBOLS = ["LightweightThemeImageOptimizer"]; + +const Cu = Components.utils; +const Ci = Components.interfaces; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "Services", + "resource://gre/modules/Services.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "FileUtils", + "resource://gre/modules/FileUtils.jsm"); + +const ORIGIN_TOP_RIGHT = 1; +const ORIGIN_BOTTOM_LEFT = 2; + +this.LightweightThemeImageOptimizer = { + optimize: function(aThemeData, aScreen) { + let data = Object.assign({}, aThemeData); + if (!data.headerURL) { + return data; + } + + data.headerURL = ImageCropper.getCroppedImageURL( + data.headerURL, aScreen, ORIGIN_TOP_RIGHT); + + if (data.footerURL) { + data.footerURL = ImageCropper.getCroppedImageURL( + data.footerURL, aScreen, ORIGIN_BOTTOM_LEFT); + } + + return data; + }, + + purge: function() { + let dir = FileUtils.getDir("ProfD", ["lwtheme"]); + dir.followLinks = false; + try { + dir.remove(true); + } catch (e) {} + } +}; + +Object.freeze(LightweightThemeImageOptimizer); + +var ImageCropper = { + _inProgress: {}, + + getCroppedImageURL: function(aImageURL, aScreen, aOrigin) { + // We can crop local files, only. + if (!aImageURL.startsWith("file://")) { + return aImageURL; + } + + // Generate the cropped image's file name using its + // base name and the current screen size. + let uri = Services.io.newURI(aImageURL, null, null); + let file = uri.QueryInterface(Ci.nsIFileURL).file; + + // Make sure the source file exists. + if (!file.exists()) { + return aImageURL; + } + + let fileName = file.leafName + "-" + aScreen.width + "x" + aScreen.height; + let croppedFile = FileUtils.getFile("ProfD", ["lwtheme", fileName]); + + // If we have a local file that is not in progress, return it. + if (croppedFile.exists() && !(croppedFile.path in this._inProgress)) { + let fileURI = Services.io.newFileURI(croppedFile); + + // Copy the query part to avoid wrong caching. + fileURI.QueryInterface(Ci.nsIURL).query = uri.query; + return fileURI.spec; + } + + // Crop the given image in the background. + this._crop(uri, croppedFile, aScreen, aOrigin); + + // Return the original image while we're waiting for the cropped version + // to be written to disk. + return aImageURL; + }, + + _crop: function(aURI, aTargetFile, aScreen, aOrigin) { + let inProgress = this._inProgress; + inProgress[aTargetFile.path] = true; + + function resetInProgress() { + delete inProgress[aTargetFile.path]; + } + + ImageFile.read(aURI, function(aInputStream, aContentType) { + if (aInputStream && aContentType) { + let image = ImageTools.decode(aInputStream, aContentType); + if (image && image.width && image.height) { + let stream = ImageTools.encode(image, aScreen, aOrigin, aContentType); + if (stream) { + ImageFile.write(aTargetFile, stream, resetInProgress); + return; + } + } + } + + resetInProgress(); + }); + } +}; + +var ImageFile = { + read: function(aURI, aCallback) { + this._netUtil.asyncFetch({ + uri: aURI, + loadUsingSystemPrincipal: true, + contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE + }, function(aInputStream, aStatus, aRequest) { + if (Components.isSuccessCode(aStatus) && aRequest instanceof Ci.nsIChannel) { + let channel = aRequest.QueryInterface(Ci.nsIChannel); + aCallback(aInputStream, channel.contentType); + } else { + aCallback(); + } + }); + }, + + write: function(aFile, aInputStream, aCallback) { + let fos = FileUtils.openSafeFileOutputStream(aFile); + this._netUtil.asyncCopy(aInputStream, fos, function(aResult) { + FileUtils.closeSafeFileOutputStream(fos); + + // Remove the file if writing was not successful. + if (!Components.isSuccessCode(aResult)) { + try { + aFile.remove(false); + } catch (e) {} + } + + aCallback(); + }); + } +}; + +XPCOMUtils.defineLazyModuleGetter(ImageFile, "_netUtil", + "resource://gre/modules/NetUtil.jsm", "NetUtil"); + +var ImageTools = { + decode: function(aInputStream, aContentType) { + let outParam = {value: null}; + + try { + this._imgTools.decodeImageData(aInputStream, aContentType, outParam); + } catch (e) {} + + return outParam.value; + }, + + encode: function(aImage, aScreen, aOrigin, aContentType) { + let stream; + let width = Math.min(aImage.width, aScreen.width); + let height = Math.min(aImage.height, aScreen.height); + let x = aOrigin == ORIGIN_TOP_RIGHT ? aImage.width - width : 0; + + try { + stream = this._imgTools.encodeCroppedImage(aImage, aContentType, x, 0, + width, height); + } catch (e) {} + + return stream; + } +}; + +XPCOMUtils.defineLazyServiceGetter(ImageTools, "_imgTools", + "@mozilla.org/image/tools;1", "imgITools"); + diff --git a/toolkit/mozapps/extensions/internal/PluginProvider.jsm b/toolkit/mozapps/extensions/internal/PluginProvider.jsm new file mode 100644 index 0000000000..075159a9ac --- /dev/null +++ b/toolkit/mozapps/extensions/internal/PluginProvider.jsm @@ -0,0 +1,600 @@ +/* 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 Cu = Components.utils; + +this.EXPORTED_SYMBOLS = []; + +Cu.import("resource://gre/modules/AddonManager.jsm"); +/* globals AddonManagerPrivate*/ +Cu.import("resource://gre/modules/Services.jsm"); + +const URI_EXTENSION_STRINGS = "chrome://mozapps/locale/extensions/extensions.properties"; +const STRING_TYPE_NAME = "type.%ID%.name"; +const LIST_UPDATED_TOPIC = "plugins-list-updated"; +const FLASH_MIME_TYPE = "application/x-shockwave-flash"; + +Cu.import("resource://gre/modules/Log.jsm"); +const LOGGER_ID = "addons.plugins"; + +// Create a new logger for use by the Addons Plugin Provider +// (Requires AddonManager.jsm) +var logger = Log.repository.getLogger(LOGGER_ID); + +function getIDHashForString(aStr) { + // return the two-digit hexadecimal code for a byte + let toHexString = charCode => ("0" + charCode.toString(16)).slice(-2); + + let hasher = Cc["@mozilla.org/security/hash;1"]. + createInstance(Ci.nsICryptoHash); + hasher.init(Ci.nsICryptoHash.MD5); + let stringStream = Cc["@mozilla.org/io/string-input-stream;1"]. + createInstance(Ci.nsIStringInputStream); + stringStream.data = aStr ? aStr : "null"; + hasher.updateFromStream(stringStream, -1); + + // convert the binary hash data to a hex string. + let binary = hasher.finish(false); + let hash = Array.from(binary, c => toHexString(c.charCodeAt(0))); + hash = hash.join("").toLowerCase(); + return "{" + hash.substr(0, 8) + "-" + + hash.substr(8, 4) + "-" + + hash.substr(12, 4) + "-" + + hash.substr(16, 4) + "-" + + hash.substr(20) + "}"; +} + +var PluginProvider = { + get name() { + return "PluginProvider"; + }, + + // A dictionary mapping IDs to names and descriptions + plugins: null, + + startup: function() { + Services.obs.addObserver(this, LIST_UPDATED_TOPIC, false); + Services.obs.addObserver(this, AddonManager.OPTIONS_NOTIFICATION_DISPLAYED, false); + }, + + /** + * Called when the application is shutting down. Only necessary for tests + * to be able to simulate a shutdown. + */ + shutdown: function() { + this.plugins = null; + Services.obs.removeObserver(this, AddonManager.OPTIONS_NOTIFICATION_DISPLAYED); + Services.obs.removeObserver(this, LIST_UPDATED_TOPIC); + }, + + observe: function(aSubject, aTopic, aData) { + switch (aTopic) { + case AddonManager.OPTIONS_NOTIFICATION_DISPLAYED: + this.getAddonByID(aData, function(plugin) { + if (!plugin) + return; + + let libLabel = aSubject.getElementById("pluginLibraries"); + libLabel.textContent = plugin.pluginLibraries.join(", "); + + let typeLabel = aSubject.getElementById("pluginMimeTypes"), types = []; + for (let type of plugin.pluginMimeTypes) { + let extras = [type.description.trim(), type.suffixes]. + filter(x => x).join(": "); + types.push(type.type + (extras ? " (" + extras + ")" : "")); + } + typeLabel.textContent = types.join(",\n"); + let showProtectedModePref = canDisableFlashProtectedMode(plugin); + aSubject.getElementById("pluginEnableProtectedMode") + .setAttribute("collapsed", showProtectedModePref ? "" : "true"); + }); + break; + case LIST_UPDATED_TOPIC: + if (this.plugins) + this.updatePluginList(); + break; + } + }, + + /** + * Creates a PluginWrapper for a plugin object. + */ + buildWrapper: function(aPlugin) { + return new PluginWrapper(aPlugin.id, + aPlugin.name, + aPlugin.description, + aPlugin.tags); + }, + + /** + * 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(aId, aCallback) { + if (!this.plugins) + this.buildPluginList(); + + if (aId in this.plugins) + aCallback(this.buildWrapper(this.plugins[aId])); + else + aCallback(null); + }, + + /** + * Called to get Addons of a particular type. + * + * @param aTypes + * An array of types to fetch. Can be null to get all types. + * @param callback + * A callback to pass an array of Addons to + */ + getAddonsByTypes: function(aTypes, aCallback) { + if (aTypes && aTypes.indexOf("plugin") < 0) { + aCallback([]); + return; + } + + if (!this.plugins) + this.buildPluginList(); + + let results = []; + + for (let id in this.plugins) + this.getAddonByID(id, (addon) => results.push(addon)); + + aCallback(results); + }, + + /** + * 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(aTypes, aCallback) { + aCallback([]); + }, + + /** + * Called to get the current AddonInstalls, optionally restricting by type. + * + * @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(aTypes, aCallback) { + aCallback([]); + }, + + /** + * Builds a list of the current plugins reported by the plugin host + * + * @return a dictionary of plugins indexed by our generated ID + */ + getPluginList: function() { + let tags = Cc["@mozilla.org/plugin/host;1"]. + getService(Ci.nsIPluginHost). + getPluginTags({}); + + let list = {}; + let seenPlugins = {}; + for (let tag of tags) { + if (!(tag.name in seenPlugins)) + seenPlugins[tag.name] = {}; + if (!(tag.description in seenPlugins[tag.name])) { + let plugin = { + id: getIDHashForString(tag.name + tag.description), + name: tag.name, + description: tag.description, + tags: [tag] + }; + + seenPlugins[tag.name][tag.description] = plugin; + list[plugin.id] = plugin; + } + else { + seenPlugins[tag.name][tag.description].tags.push(tag); + } + } + + return list; + }, + + /** + * Builds the list of known plugins from the plugin host + */ + buildPluginList: function() { + this.plugins = this.getPluginList(); + }, + + /** + * Updates the plugins from the plugin host by comparing the current plugins + * to the last known list sending out any necessary API notifications for + * changes. + */ + updatePluginList: function() { + let newList = this.getPluginList(); + + let lostPlugins = Object.keys(this.plugins).filter(id => !(id in newList)). + map(id => this.buildWrapper(this.plugins[id])); + let newPlugins = Object.keys(newList).filter(id => !(id in this.plugins)). + map(id => this.buildWrapper(newList[id])); + let matchedIDs = Object.keys(newList).filter(id => id in this.plugins); + + // The plugin host generates new tags for every plugin after a scan and + // if the plugin's filename has changed then the disabled state won't have + // been carried across, send out notifications for anything that has + // changed (see bug 830267). + let changedWrappers = []; + for (let id of matchedIDs) { + let oldWrapper = this.buildWrapper(this.plugins[id]); + let newWrapper = this.buildWrapper(newList[id]); + + if (newWrapper.isActive != oldWrapper.isActive) { + AddonManagerPrivate.callAddonListeners(newWrapper.isActive ? + "onEnabling" : "onDisabling", + newWrapper, false); + changedWrappers.push(newWrapper); + } + } + + // Notify about new installs + for (let plugin of newPlugins) { + AddonManagerPrivate.callInstallListeners("onExternalInstall", null, + plugin, null, false); + AddonManagerPrivate.callAddonListeners("onInstalling", plugin, false); + } + + // Notify for any plugins that have vanished. + for (let plugin of lostPlugins) + AddonManagerPrivate.callAddonListeners("onUninstalling", plugin, false); + + this.plugins = newList; + + // Signal that new installs are complete + for (let plugin of newPlugins) + AddonManagerPrivate.callAddonListeners("onInstalled", plugin); + + // Signal that enables/disables are complete + for (let wrapper of changedWrappers) { + AddonManagerPrivate.callAddonListeners(wrapper.isActive ? + "onEnabled" : "onDisabled", + wrapper); + } + + // Signal that uninstalls are complete + for (let plugin of lostPlugins) + AddonManagerPrivate.callAddonListeners("onUninstalled", plugin); + } +}; + +function isFlashPlugin(aPlugin) { + for (let type of aPlugin.pluginMimeTypes) { + if (type.type == FLASH_MIME_TYPE) { + return true; + } + } + return false; +} +// Protected mode is win32-only, not win64 +function canDisableFlashProtectedMode(aPlugin) { + return isFlashPlugin(aPlugin) && Services.appinfo.XPCOMABI == "x86-msvc"; +} + +const wrapperMap = new WeakMap(); +let pluginFor = wrapper => wrapperMap.get(wrapper); + +/** + * The PluginWrapper wraps a set of nsIPluginTags to provide the data visible to + * public callers through the API. + */ +function PluginWrapper(id, name, description, tags) { + wrapperMap.set(this, { id, name, description, tags }); +} + +PluginWrapper.prototype = { + get id() { + return pluginFor(this).id; + }, + + get type() { + return "plugin"; + }, + + get name() { + return pluginFor(this).name; + }, + + get creator() { + return null; + }, + + get description() { + return pluginFor(this).description.replace(/<\/?[a-z][^>]*>/gi, " "); + }, + + get version() { + let { tags: [tag] } = pluginFor(this); + return tag.version; + }, + + get homepageURL() { + let { description } = pluginFor(this); + if (/]*>/i.test(description)) + return /"'\s]*)/i.exec(description)[1]; + return null; + }, + + get isActive() { + let { tags: [tag] } = pluginFor(this); + return !tag.blocklisted && !tag.disabled; + }, + + get appDisabled() { + let { tags: [tag] } = pluginFor(this); + return tag.blocklisted; + }, + + get userDisabled() { + let { tags: [tag] } = pluginFor(this); + if (tag.disabled) + return true; + + if ((Services.prefs.getBoolPref("plugins.click_to_play") && tag.clicktoplay) || + this.blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_UPDATE_AVAILABLE || + this.blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_NO_UPDATE) + return AddonManager.STATE_ASK_TO_ACTIVATE; + + return false; + }, + + set userDisabled(val) { + let previousVal = this.userDisabled; + if (val === previousVal) + return val; + + let { tags } = pluginFor(this); + + for (let tag of tags) { + if (val === true) + tag.enabledState = Ci.nsIPluginTag.STATE_DISABLED; + else if (val === false) + tag.enabledState = Ci.nsIPluginTag.STATE_ENABLED; + else if (val == AddonManager.STATE_ASK_TO_ACTIVATE) + tag.enabledState = Ci.nsIPluginTag.STATE_CLICKTOPLAY; + } + + // If 'userDisabled' was 'true' and we're going to a state that's not + // that, we're enabling, so call those listeners. + if (previousVal === true && val !== true) { + AddonManagerPrivate.callAddonListeners("onEnabling", this, false); + AddonManagerPrivate.callAddonListeners("onEnabled", this); + } + + // If 'userDisabled' was not 'true' and we're going to a state where + // it is, we're disabling, so call those listeners. + if (previousVal !== true && val === true) { + AddonManagerPrivate.callAddonListeners("onDisabling", this, false); + AddonManagerPrivate.callAddonListeners("onDisabled", this); + } + + // If the 'userDisabled' value involved AddonManager.STATE_ASK_TO_ACTIVATE, + // call the onPropertyChanged listeners. + if (previousVal == AddonManager.STATE_ASK_TO_ACTIVATE || + val == AddonManager.STATE_ASK_TO_ACTIVATE) { + AddonManagerPrivate.callAddonListeners("onPropertyChanged", this, ["userDisabled"]); + } + + return val; + }, + + get blocklistState() { + let { tags: [tag] } = pluginFor(this); + let bs = Cc["@mozilla.org/extensions/blocklist;1"]. + getService(Ci.nsIBlocklistService); + return bs.getPluginBlocklistState(tag); + }, + + get blocklistURL() { + let { tags: [tag] } = pluginFor(this); + let bs = Cc["@mozilla.org/extensions/blocklist;1"]. + getService(Ci.nsIBlocklistService); + return bs.getPluginBlocklistURL(tag); + }, + + get size() { + function getDirectorySize(aFile) { + let size = 0; + let entries = aFile.directoryEntries.QueryInterface(Ci.nsIDirectoryEnumerator); + let entry; + while ((entry = entries.nextFile)) { + if (entry.isSymlink() || !entry.isDirectory()) + size += entry.fileSize; + else + size += getDirectorySize(entry); + } + entries.close(); + return size; + } + + let size = 0; + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + for (let tag of pluginFor(this).tags) { + file.initWithPath(tag.fullpath); + if (file.isDirectory()) + size += getDirectorySize(file); + else + size += file.fileSize; + } + return size; + }, + + get pluginLibraries() { + let libs = []; + for (let tag of pluginFor(this).tags) + libs.push(tag.filename); + return libs; + }, + + get pluginFullpath() { + let paths = []; + for (let tag of pluginFor(this).tags) + paths.push(tag.fullpath); + return paths; + }, + + get pluginMimeTypes() { + let types = []; + for (let tag of pluginFor(this).tags) { + let mimeTypes = tag.getMimeTypes({}); + let mimeDescriptions = tag.getMimeDescriptions({}); + let extensions = tag.getExtensions({}); + for (let i = 0; i < mimeTypes.length; i++) { + let type = {}; + type.type = mimeTypes[i]; + type.description = mimeDescriptions[i]; + type.suffixes = extensions[i]; + + types.push(type); + } + } + return types; + }, + + get installDate() { + let date = 0; + for (let tag of pluginFor(this).tags) { + date = Math.max(date, tag.lastModifiedTime); + } + return new Date(date); + }, + + get scope() { + let { tags: [tag] } = pluginFor(this); + let path = tag.fullpath; + // Plugins inside the application directory are in the application scope + let dir = Services.dirsvc.get("APlugns", Ci.nsIFile); + if (path.startsWith(dir.path)) + return AddonManager.SCOPE_APPLICATION; + + // Plugins inside the profile directory are in the profile scope + dir = Services.dirsvc.get("ProfD", Ci.nsIFile); + if (path.startsWith(dir.path)) + return AddonManager.SCOPE_PROFILE; + + // Plugins anywhere else in the user's home are in the user scope, + // but not all platforms have a home directory. + try { + dir = Services.dirsvc.get("Home", Ci.nsIFile); + if (path.startsWith(dir.path)) + return AddonManager.SCOPE_USER; + } catch (e) { + if (!e.result || e.result != Components.results.NS_ERROR_FAILURE) + throw e; + // Do nothing: missing "Home". + } + + // Any other locations are system scope + return AddonManager.SCOPE_SYSTEM; + }, + + get pendingOperations() { + return AddonManager.PENDING_NONE; + }, + + get operationsRequiringRestart() { + return AddonManager.OP_NEEDS_RESTART_NONE; + }, + + get permissions() { + let { tags: [tag] } = pluginFor(this); + let permissions = 0; + if (tag.isEnabledStateLocked) { + return permissions; + } + if (!this.appDisabled) { + + if (this.userDisabled !== true) + permissions |= AddonManager.PERM_CAN_DISABLE; + + let blocklistState = this.blocklistState; + let isCTPBlocklisted = + (blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_NO_UPDATE || + blocklistState == Ci.nsIBlocklistService.STATE_VULNERABLE_UPDATE_AVAILABLE); + + if (this.userDisabled !== AddonManager.STATE_ASK_TO_ACTIVATE && + (Services.prefs.getBoolPref("plugins.click_to_play") || + isCTPBlocklisted)) { + permissions |= AddonManager.PERM_CAN_ASK_TO_ACTIVATE; + } + + if (this.userDisabled !== false && !isCTPBlocklisted) { + permissions |= AddonManager.PERM_CAN_ENABLE; + } + } + return permissions; + }, + + get optionsType() { + if (canDisableFlashProtectedMode(this)) { + return AddonManager.OPTIONS_TYPE_INLINE; + } + return AddonManager.OPTIONS_TYPE_INLINE_INFO; + }, + + get optionsURL() { + return "chrome://mozapps/content/extensions/pluginPrefs.xul"; + }, + + get updateDate() { + return this.installDate; + }, + + get isCompatible() { + return true; + }, + + get isPlatformCompatible() { + return true; + }, + + get providesUpdatesSecurely() { + return true; + }, + + get foreignInstall() { + return true; + }, + + isCompatibleWith: function(aAppVersion, aPlatformVersion) { + return true; + }, + + findUpdates: function(aListener, aReason, aAppVersion, aPlatformVersion) { + if ("onNoCompatibilityUpdateAvailable" in aListener) + aListener.onNoCompatibilityUpdateAvailable(this); + if ("onNoUpdateAvailable" in aListener) + aListener.onNoUpdateAvailable(this); + if ("onUpdateFinished" in aListener) + aListener.onUpdateFinished(this); + } +}; + +AddonManagerPrivate.registerProvider(PluginProvider, [ + new AddonManagerPrivate.AddonType("plugin", URI_EXTENSION_STRINGS, + STRING_TYPE_NAME, + AddonManager.VIEW_TYPE_LIST, 6000, + AddonManager.TYPE_SUPPORTS_ASK_TO_ACTIVATE) +]); diff --git a/toolkit/mozapps/extensions/internal/ProductAddonChecker.jsm b/toolkit/mozapps/extensions/internal/ProductAddonChecker.jsm new file mode 100644 index 0000000000..f98dd2a943 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/ProductAddonChecker.jsm @@ -0,0 +1,467 @@ +/* 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 { classes: Cc, interfaces: Ci, utils: Cu } = Components; + +const LOCAL_EME_SOURCES = [{ + "id": "gmp-eme-adobe", + "src": "chrome://global/content/gmp-sources/eme-adobe.json" +}, { + "id": "gmp-gmpopenh264", + "src": "chrome://global/content/gmp-sources/openh264.json" +}, { + "id": "gmp-widevinecdm", + "src": "chrome://global/content/gmp-sources/widevinecdm.json" +}]; + +this.EXPORTED_SYMBOLS = [ "ProductAddonChecker" ]; + +Cu.importGlobalProperties(["XMLHttpRequest"]); + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/Task.jsm"); +Cu.import("resource://gre/modules/Log.jsm"); +Cu.import("resource://gre/modules/CertUtils.jsm"); +/* globals checkCert, BadCertHandler*/ +Cu.import("resource://gre/modules/FileUtils.jsm"); +Cu.import("resource://gre/modules/NetUtil.jsm"); +Cu.import("resource://gre/modules/osfile.jsm"); + +/* globals GMPPrefs */ +XPCOMUtils.defineLazyModuleGetter(this, "GMPPrefs", + "resource://gre/modules/GMPUtils.jsm"); + +/* globals OS */ + +XPCOMUtils.defineLazyModuleGetter(this, "UpdateUtils", + "resource://gre/modules/UpdateUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "ServiceRequest", + "resource://gre/modules/ServiceRequest.jsm"); + +// This exists so that tests can override the XHR behaviour for downloading +// the addon update XML file. +var CreateXHR = function() { + return Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]. + createInstance(Ci.nsISupports); +} + +var logger = Log.repository.getLogger("addons.productaddons"); + +/** + * Number of milliseconds after which we need to cancel `downloadXML`. + * + * Bug 1087674 suggests that the XHR we use in `downloadXML` may + * never terminate in presence of network nuisances (e.g. strange + * antivirus behavior). This timeout is a defensive measure to ensure + * that we fail cleanly in such case. + */ +const TIMEOUT_DELAY_MS = 20000; +// Chunk size for the incremental downloader +const DOWNLOAD_CHUNK_BYTES_SIZE = 300000; +// Incremental downloader interval +const DOWNLOAD_INTERVAL = 0; +// How much of a file to read into memory at a time for hashing +const HASH_CHUNK_SIZE = 8192; + +/** + * Gets the status of an XMLHttpRequest either directly or from its underlying + * channel. + * + * @param request + * The XMLHttpRequest. + * @return an integer status value. + */ +function getRequestStatus(request) { + let status = null; + try { + status = request.status; + } + catch (e) { + } + + if (status != null) { + return status; + } + + return request.channel.QueryInterface(Ci.nsIRequest).status; +} + +/** + * Downloads an XML document from a URL optionally testing the SSL certificate + * for certain attributes. + * + * @param url + * The url to download from. + * @param allowNonBuiltIn + * Whether to trust SSL certificates without a built-in CA issuer. + * @param allowedCerts + * The list of certificate attributes to match the SSL certificate + * against or null to skip checks. + * @return a promise that resolves to the DOM document downloaded or rejects + * with a JS exception in case of error. + */ +function downloadXML(url, allowNonBuiltIn = false, allowedCerts = null) { + return new Promise((resolve, reject) => { + let request = CreateXHR(); + // This is here to let unit test code override XHR + if (request.wrappedJSObject) { + request = request.wrappedJSObject; + } + request.open("GET", url, true); + request.channel.notificationCallbacks = new BadCertHandler(allowNonBuiltIn); + // Prevent the request from reading from the cache. + request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE; + // Prevent the request from writing to the cache. + request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING; + // Use conservative TLS settings. See bug 1325501. + // TODO move to ServiceRequest. + if (request.channel instanceof Ci.nsIHttpChannelInternal) { + request.channel.QueryInterface(Ci.nsIHttpChannelInternal).beConservative = true; + } + request.timeout = TIMEOUT_DELAY_MS; + + request.overrideMimeType("text/xml"); + // The Cache-Control header is only interpreted by proxies and the + // final destination. It does not help if a resource is already + // cached locally. + request.setRequestHeader("Cache-Control", "no-cache"); + // HTTP/1.0 servers might not implement Cache-Control and + // might only implement Pragma: no-cache + request.setRequestHeader("Pragma", "no-cache"); + + let fail = (event) => { + let request = event.target; + let status = getRequestStatus(request); + let message = "Failed downloading XML, status: " + status + ", reason: " + event.type; + logger.warn(message); + let ex = new Error(message); + ex.status = status; + reject(ex); + }; + + let success = (event) => { + logger.info("Completed downloading document"); + let request = event.target; + + try { + checkCert(request.channel, allowNonBuiltIn, allowedCerts); + } catch (ex) { + logger.error("Request failed certificate checks: " + ex); + ex.status = getRequestStatus(request); + reject(ex); + return; + } + + resolve(request.responseXML); + }; + + request.addEventListener("error", fail, false); + request.addEventListener("abort", fail, false); + request.addEventListener("timeout", fail, false); + request.addEventListener("load", success, false); + + logger.info("sending request to: " + url); + request.send(null); + }); +} + +function downloadJSON(uri) { + logger.info("fetching config from: " + uri); + return new Promise((resolve, reject) => { + let xmlHttp = new ServiceRequest({mozAnon: true}); + + xmlHttp.onload = function(aResponse) { + resolve(JSON.parse(this.responseText)); + }; + + xmlHttp.onerror = function(e) { + reject("Fetching " + uri + " results in error code: " + e.target.status); + }; + + xmlHttp.open("GET", uri); + xmlHttp.overrideMimeType("application/json"); + xmlHttp.send(); + }); +} + + +/** + * Parses a list of add-ons from a DOM document. + * + * @param document + * The DOM document to parse. + * @return null if there is no element otherwise an object containing + * an array of the addons listed and a field notifying whether the + * fallback was used. + */ +function parseXML(document) { + // Check that the root element is correct + if (document.documentElement.localName != "updates") { + throw new Error("got node name: " + document.documentElement.localName + + ", expected: updates"); + } + + // Check if there are any addons elements in the updates element + let addons = document.querySelector("updates:root > addons"); + if (!addons) { + return null; + } + + let results = []; + let addonList = document.querySelectorAll("updates:root > addons > addon"); + for (let addonElement of addonList) { + let addon = {}; + + for (let name of ["id", "URL", "hashFunction", "hashValue", "version", "size"]) { + if (addonElement.hasAttribute(name)) { + addon[name] = addonElement.getAttribute(name); + } + } + addon.size = Number(addon.size) || undefined; + + results.push(addon); + } + + return { + usedFallback: false, + gmpAddons: results + }; +} + +/** + * If downloading from the network fails (AUS server is down), + * load the sources from local build configuration. + */ +function downloadLocalConfig() { + + if (!GMPPrefs.get(GMPPrefs.KEY_UPDATE_ENABLED, true)) { + logger.info("Updates are disabled via media.gmp-manager.updateEnabled"); + return Promise.resolve({usedFallback: true, gmpAddons: []}); + } + + return Promise.all(LOCAL_EME_SOURCES.map(conf => { + return downloadJSON(conf.src).then(addons => { + + let platforms = addons.vendors[conf.id].platforms; + let target = Services.appinfo.OS + "_" + UpdateUtils.ABI; + let details = null; + + while (!details) { + if (!(target in platforms)) { + // There was no matching platform so return false, this addon + // will be filtered from the results below + logger.info("no details found for: " + target); + return false; + } + // Field either has the details of the binary or is an alias + // to another build target key that does + if (platforms[target].alias) { + target = platforms[target].alias; + } else { + details = platforms[target]; + } + } + + logger.info("found plugin: " + conf.id); + return { + "id": conf.id, + "URL": details.fileUrl, + "hashFunction": addons.hashFunction, + "hashValue": details.hashValue, + "version": addons.vendors[conf.id].version, + "size": details.filesize + }; + }); + })).then(addons => { + + // Some filters may not match this platform so + // filter those out + addons = addons.filter(x => x !== false); + + return { + usedFallback: true, + gmpAddons: addons + }; + }); +} + +/** + * Downloads file from a URL using XHR. + * + * @param url + * The url to download from. + * @return a promise that resolves to the path of a temporary file or rejects + * with a JS exception in case of error. + */ +function downloadFile(url) { + return new Promise((resolve, reject) => { + let xhr = new XMLHttpRequest(); + xhr.onload = function(response) { + logger.info("downloadXHR File download. status=" + xhr.status); + if (xhr.status != 200 && xhr.status != 206) { + reject(Components.Exception("File download failed", xhr.status)); + return; + } + Task.spawn(function* () { + let f = yield OS.File.openUnique(OS.Path.join(OS.Constants.Path.tmpDir, "tmpaddon")); + let path = f.path; + logger.info(`Downloaded file will be saved to ${path}`); + yield f.file.close(); + yield OS.File.writeAtomic(path, new Uint8Array(xhr.response)); + return path; + }).then(resolve, reject); + }; + + let fail = (event) => { + let request = event.target; + let status = getRequestStatus(request); + let message = "Failed downloading via XHR, status: " + status + ", reason: " + event.type; + logger.warn(message); + let ex = new Error(message); + ex.status = status; + reject(ex); + }; + xhr.addEventListener("error", fail); + xhr.addEventListener("abort", fail); + + xhr.responseType = "arraybuffer"; + try { + xhr.open("GET", url); + // Use conservative TLS settings. See bug 1325501. + // TODO move to ServiceRequest. + if (xhr.channel instanceof Ci.nsIHttpChannelInternal) { + xhr.channel.QueryInterface(Ci.nsIHttpChannelInternal).beConservative = true; + } + xhr.send(null); + } catch (ex) { + reject(ex); + } + }); +} + +/** + * Convert a string containing binary values to hex. + */ +function binaryToHex(input) { + let result = ""; + for (let i = 0; i < input.length; ++i) { + let hex = input.charCodeAt(i).toString(16); + if (hex.length == 1) { + hex = "0" + hex; + } + result += hex; + } + return result; +} + +/** + * Calculates the hash of a file. + * + * @param hashFunction + * The type of hash function to use, must be supported by nsICryptoHash. + * @param path + * The path of the file to hash. + * @return a promise that resolves to hash of the file or rejects with a JS + * exception in case of error. + */ +var computeHash = Task.async(function*(hashFunction, path) { + let file = yield OS.File.open(path, { existing: true, read: true }); + try { + let hasher = Cc["@mozilla.org/security/hash;1"]. + createInstance(Ci.nsICryptoHash); + hasher.initWithString(hashFunction); + + let bytes; + do { + bytes = yield file.read(HASH_CHUNK_SIZE); + hasher.update(bytes, bytes.length); + } while (bytes.length == HASH_CHUNK_SIZE); + + return binaryToHex(hasher.finish(false)); + } + finally { + yield file.close(); + } +}); + +/** + * Verifies that a downloaded file matches what was expected. + * + * @param properties + * The properties to check, `size` and `hashFunction` with `hashValue` + * are supported. Any properties missing won't be checked. + * @param path + * The path of the file to check. + * @return a promise that resolves if the file matched or rejects with a JS + * exception in case of error. + */ +var verifyFile = Task.async(function*(properties, path) { + if (properties.size !== undefined) { + let stat = yield OS.File.stat(path); + if (stat.size != properties.size) { + throw new Error("Downloaded file was " + stat.size + " bytes but expected " + properties.size + " bytes."); + } + } + + if (properties.hashFunction !== undefined) { + let expectedDigest = properties.hashValue.toLowerCase(); + let digest = yield computeHash(properties.hashFunction, path); + if (digest != expectedDigest) { + throw new Error("Hash was `" + digest + "` but expected `" + expectedDigest + "`."); + } + } +}); + +const ProductAddonChecker = { + /** + * Downloads a list of add-ons from a URL optionally testing the SSL + * certificate for certain attributes. + * + * @param url + * The url to download from. + * @param allowNonBuiltIn + * Whether to trust SSL certificates without a built-in CA issuer. + * @param allowedCerts + * The list of certificate attributes to match the SSL certificate + * against or null to skip checks. + * @return a promise that resolves to an object containing the list of add-ons + * and whether the local fallback was used, or rejects with a JS + * exception in case of error. + */ + getProductAddonList: function(url, allowNonBuiltIn = false, allowedCerts = null) { + if (!GMPPrefs.get(GMPPrefs.KEY_UPDATE_ENABLED, true)) { + logger.info("Updates are disabled via media.gmp-manager.updateEnabled"); + return Promise.resolve({usedFallback: true, gmpAddons: []}); + } + + return downloadXML(url, allowNonBuiltIn, allowedCerts) + .then(parseXML) + .catch(downloadLocalConfig); + }, + + /** + * Downloads an add-on to a local file and checks that it matches the expected + * file. The caller is responsible for deleting the temporary file returned. + * + * @param addon + * The addon to download. + * @return a promise that resolves to the temporary file downloaded or rejects + * with a JS exception in case of error. + */ + downloadAddon: Task.async(function*(addon) { + let path = yield downloadFile(addon.URL); + try { + yield verifyFile(addon, path); + return path; + } + catch (e) { + yield OS.File.remove(path); + throw e; + } + }) +} diff --git a/toolkit/mozapps/extensions/internal/SpellCheckDictionaryBootstrap.js b/toolkit/mozapps/extensions/internal/SpellCheckDictionaryBootstrap.js new file mode 100644 index 0000000000..f4f557fc22 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/SpellCheckDictionaryBootstrap.js @@ -0,0 +1,17 @@ +/* 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/. */ + +var hunspell, dir; + +function startup(data) { + hunspell = Components.classes["@mozilla.org/spellchecker/engine;1"] + .getService(Components.interfaces.mozISpellCheckingEngine); + dir = data.installPath.clone(); + dir.append("dictionaries"); + hunspell.addDirectory(dir); +} + +function shutdown() { + hunspell.removeDirectory(dir); +} diff --git a/toolkit/mozapps/extensions/internal/WebExtensionBootstrap.js b/toolkit/mozapps/extensions/internal/WebExtensionBootstrap.js new file mode 100644 index 0000000000..a920c2eae8 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/WebExtensionBootstrap.js @@ -0,0 +1,39 @@ +/* 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"; + +Components.utils.import("resource://gre/modules/Extension.jsm"); + +var extension; + +const BOOTSTRAP_REASON_TO_STRING_MAP = { + 1: "APP_STARTUP", + 2: "APP_SHUTDOWN", + 3: "ADDON_ENABLE", + 4: "ADDON_DISABLE", + 5: "ADDON_INSTALL", + 6: "ADDON_UNINSTALL", + 7: "ADDON_UPGRADE", + 8: "ADDON_DOWNGRADE", +} + +function install(data, reason) +{ +} + +function startup(data, reason) +{ + extension = new Extension(data, BOOTSTRAP_REASON_TO_STRING_MAP[reason]); + extension.startup(); +} + +function shutdown(data, reason) +{ + extension.shutdown(); +} + +function uninstall(data, reason) +{ +} diff --git a/toolkit/mozapps/extensions/internal/XPIProvider.jsm b/toolkit/mozapps/extensions/internal/XPIProvider.jsm new file mode 100644 index 0000000000..87e09cef18 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/XPIProvider.jsm @@ -0,0 +1,9305 @@ + /* 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"]; + +const CONSTANTS = {}; +Cu.import("resource://gre/modules/addons/AddonConstants.jsm", CONSTANTS); +const { ADDON_SIGNING, REQUIRE_SIGNING } = CONSTANTS + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/AddonManager.jsm"); +Cu.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, "ExtensionData", + "resource://gre/modules/Extension.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ExtensionManagement", + "resource://gre/modules/ExtensionManagement.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Locale", + "resource://gre/modules/Locale.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"); +XPCOMUtils.defineLazyModuleGetter(this, "BrowserToolboxProcess", + "resource://devtools/client/framework/ToolboxProcess.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ConsoleAPI", + "resource://gre/modules/Console.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ProductAddonChecker", + "resource://gre/modules/addons/ProductAddonChecker.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "UpdateUtils", + "resource://gre/modules/UpdateUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "AppConstants", + "resource://gre/modules/AppConstants.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "isAddonPartOfE10SRollout", + "resource://gre/modules/addons/E10SAddonsRollout.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "LegacyExtensionsUtils", + "resource://gre/modules/LegacyExtensionsUtils.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, + "AddonPolicyService", + "@mozilla.org/addons/policy-service;1", + "nsIAddonPolicyService"); +XPCOMUtils.defineLazyServiceGetter(this, + "AddonPathService", + "@mozilla.org/addon-path-service;1", + "amIAddonPathService"); + +XPCOMUtils.defineLazyGetter(this, "CertUtils", function() { + let certUtils = {}; + Components.utils.import("resource://gre/modules/CertUtils.jsm", certUtils); + return certUtils; +}); + +Cu.importGlobalProperties(["URL"]); + +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_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_UPDATE_BACKGROUND_URL = "extensions.update.background.url"; +const PREF_EM_ENABLED_ADDONS = "extensions.enabledAddons"; +const PREF_EM_EXTENSION_FORMAT = "extensions."; +const PREF_EM_ENABLED_SCOPES = "extensions.enabledScopes"; +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"; +// xpinstall.signatures.required only supported in dev builds +const PREF_XPI_SIGNATURES_REQUIRED = "xpinstall.signatures.required"; +const PREF_XPI_SIGNATURES_DEV_ROOT = "xpinstall.signatures.dev-root"; +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_INTERPOSITION_ENABLED = "extensions.interposition.enabled"; +const PREF_SYSTEM_ADDON_SET = "extensions.systemAddonSet"; +const PREF_SYSTEM_ADDON_UPDATE_URL = "extensions.systemAddon.update.url"; +const PREF_E10S_BLOCK_ENABLE = "extensions.e10sBlocksEnabling"; +const PREF_E10S_ADDON_BLOCKLIST = "extensions.e10s.rollout.blocklist"; +const PREF_E10S_ADDON_POLICY = "extensions.e10s.rollout.policy"; +const PREF_E10S_HAS_NONEXEMPT_ADDON = "extensions.e10s.rollout.hasAddon"; + +const PREF_EM_MIN_COMPAT_APP_VERSION = "extensions.minCompatibleAppVersion"; +const PREF_EM_MIN_COMPAT_PLATFORM_VERSION = "extensions.minCompatiblePlatformVersion"; + +const PREF_CHECKCOMAT_THEMEOVERRIDE = "extensions.checkCompatibility.temporaryThemeOverride_minAppVersion"; + +const PREF_EM_HOTFIX_ID = "extensions.hotfix.id"; +const PREF_EM_CERT_CHECKATTRIBUTES = "extensions.hotfix.cert.checkAttributes"; +const PREF_EM_HOTFIX_CERTS = "extensions.hotfix.certs."; + +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_SYSTEM_ADDONS = "features"; +const DIR_STAGE = "staged"; +const DIR_TRASH = "trash"; + +const FILE_DATABASE = "extensions.json"; +const FILE_OLD_CACHE = "extensions.cache"; +const FILE_RDF_MANIFEST = "install.rdf"; +const FILE_WEB_MANIFEST = "manifest.json"; +const FILE_XPI_ADDONS_LIST = "extensions.ini"; + +const KEY_PROFILEDIR = "ProfD"; +const KEY_ADDON_APP_DIR = "XREAddonAppDir"; +const KEY_TEMPDIR = "TmpD"; +const KEY_APP_DISTRIBUTION = "XREAppDist"; +const KEY_APP_FEATURES = "XREAppFeat"; + +const KEY_APP_PROFILE = "app-profile"; +const KEY_APP_SYSTEM_ADDONS = "app-system-addons"; +const KEY_APP_SYSTEM_DEFAULTS = "app-system-defaults"; +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 KEY_APP_TEMPORARY = "app-temporary"; + +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"; + +const XPI_SIGNATURE_CHECK_PERIOD = 24 * 60 * 60; + +XPCOMUtils.defineConstant(this, "DB_SCHEMA", 19); + +const NOTIFICATION_TOOLBOXPROCESS_LOADED = "ToolboxProcessLoaded"; + +// 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 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, +}; + +if (!AppConstants.RELEASE_OR_BETA) + TYPES.apiextension = 256; + +// Some add-on types that we track internally are presented as other types +// externally +const TYPE_ALIASES = { + "webextension": "extension", + "apiextension": "extension", +}; + +const CHROME_TYPES = new Set([ + "extension", + "locale", + "experiment", +]); + +const RESTARTLESS_TYPES = new Set([ + "webextension", + "dictionary", + "experiment", + "locale", + "apiextension", +]); + +const SIGNED_TYPES = new Set([ + "webextension", + "extension", + "experiment", + "apiextension", +]); + +// This is a random number array that can be used as "salt" when generating +// an automatic ID based on the directory path of an add-on. It will prevent +// someone from creating an ID for a permanent add-on that could be replaced +// by a temporary add-on (because that would be confusing, I guess). +const TEMP_INSTALL_ID_GEN_SESSION = + new Uint8Array(Float64Array.of(Math.random()).buffer); + +// Whether add-on signing is required. +function mustSign(aType) { + if (!SIGNED_TYPES.has(aType)) + return false; + return REQUIRE_SIGNING || Preferences.get(PREF_XPI_SIGNATURES_REQUIRED, false); +} + +// 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", "XPIDatabaseReconcile"]; +/* globals XPIDatabase, XPIDatabaseReconcile*/ + +var gLazyObjectsLoaded = false; + +function loadLazyObjects() { + let uri = "resource://gre/modules/addons/XPIProviderUtils.js"; + let scope = Cu.Sandbox(Services.scriptSecurityManager.getSystemPrincipal(), { + sandboxName: uri, + wantGlobalProperties: ["TextDecoder"], + }); + + let shared = { + ADDON_SIGNING, + SIGNED_TYPES, + BOOTSTRAP_REASONS, + DB_SCHEMA, + AddonInternal, + XPIProvider, + XPIStates, + syncLoadManifestFromFile, + isUsableAddon, + recordAddonTelemetry, + applyBlocklistChanges, + flushChromeCaches, + canRunInSafeMode, + } + + for (let key of Object.keys(shared)) + scope[key] = shared[key]; + + Services.scriptloader.loadSubScript(uri, scope); + + for (let name of LAZY_OBJECTS) { + delete gGlobalScope[name]; + gGlobalScope[name] = scope[name]; + } + gLazyObjectsLoaded = true; + return scope; +} + +LAZY_OBJECTS.forEach(name => { + Object.defineProperty(gGlobalScope, name, { + get: function() { + let objs = loadLazyObjects(); + return objs[name]; + }, + configurable: true + }); +}); + + +// Behaves like Promise.all except waits for all promises to resolve/reject +// before resolving/rejecting itself +function waitForAllPromises(promises) { + return new Promise((resolve, reject) => { + let shouldReject = false; + let rejectValue = null; + + let newPromises = promises.map( + p => p.catch(value => { + shouldReject = true; + rejectValue = value; + }) + ); + Promise.all(newPromises) + .then((results) => shouldReject ? reject(rejectValue) : resolve(results)); + }); +} + +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; +} + +/** + * Converts an iterable of addon objects into a map with the add-on's ID as key. + */ +function addonMap(addons) { + return new Map(addons.map(a => [a.id, a])); +} + +/** + * 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); + } +} + +/** + * Write a given string to a file + * + * @param file + * The nsIFile instance to write into + * @param string + * The string to write + */ +function writeStringToFile(file, string) { + 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(file, FileUtils.MODE_WRONLY | FileUtils.MODE_CREATE | + FileUtils.MODE_TRUNCATE, FileUtils.PERMS_FILE, + 0); + converter.init(stream, "UTF-8", 0, 0x0000); + converter.writeString(string); + } + finally { + converter.close(); + stream.close(); + } +} + +/** + * 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(aFile, aTargetDirectory, aCopy) { + let oldFile = aCopy ? null : aFile.clone(); + let newFile = aFile.clone(); + try { + if (aCopy) { + newFile.copyTo(aTargetDirectory, null); + // copyTo does not update the nsIFile with the new. + newFile = aTargetDirectory.clone(); + newFile.append(aFile.leafName); + // Windows roaming profiles won't properly sync directories if a new file + // has an older lastModifiedTime than a previous file, so update. + newFile.lastModifiedTime = Date.now(); + } + 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(aDirectory, aTargetDirectory, aCopy) { + if (aDirectory.contains(aTargetDirectory)) { + let err = new Error(`Not installing ${aDirectory} into its own descendent ${aTargetDirectory}`); + logger.error(err); + throw err; + } + + 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); + for (let entry of entries) { + try { + this._installDirEntry(entry, newDir, aCopy); + } + catch (e) { + logger.error("Failed to " + (aCopy ? "copy" : "move") + " entry " + + entry.path, e); + throw e; + } + } + + // 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(aDirEntry, aTargetDirectory, aCopy) { + let isDir = null; + + try { + isDir = aDirEntry.isDirectory() && !aDirEntry.isSymlink(); + } + 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(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(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() { + while (this._installedFiles.length > 0) { + let move = this._installedFiles.pop(); + if (move.isMoveTo) { + move.newFile.moveTo(move.oldDir.parent, move.oldDir.leafName); + } + else if (move.newFile.isDirectory() && !move.newFile.isSymlink()) { + 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()); + } +}; + +/** + * 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(aOldAddon.wrapper, + aOldAppVersion, + aOldPlatformVersion); + let newBlocklistState = Blocklist.getAddonBlocklistState(aNewAddon.wrapper); + + // 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; + } +} + +/** + * Evaluates whether an add-on is allowed to run in safe mode. + * + * @param aAddon + * The add-on to check + * @return true if the add-on should run in safe mode + */ +function canRunInSafeMode(aAddon) { + // Even though the updated system add-ons aren't generally run in safe mode we + // include them here so their uninstall functions get called when switching + // back to the default set. + + // TODO product should make the call about temporary add-ons running + // in safe mode. assuming for now that they are. + if (aAddon._installLocation.name == KEY_APP_TEMPORARY) + return true; + + return aAddon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS || + aAddon._installLocation.name == KEY_APP_SYSTEM_ADDONS; +} + +/** + * 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 (mustSign(aAddon.type) && !aAddon.isCorrectlySigned) { + logger.warn(`Add-on ${aAddon.id} is not correctly signed.`); + return false; + } + + if (aAddon.blocklistState == Blocklist.STATE_BLOCKED) { + logger.warn(`Add-on ${aAddon.id} is blocklisted.`); + return false; + } + + // 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 (aAddon.type == "experiment") + return true; + + if (AddonManager.checkUpdateSecurity && !aAddon.providesUpdatesSecurely) { + logger.warn(`Updates for add-on ${aAddon.id} must be provided over HTTPS.`); + return false; + } + + + if (!aAddon.isPlatformCompatible) { + logger.warn(`Add-on ${aAddon.id} is not compatible with platform.`); + return false; + } + + if (aAddon.dependencies.length) { + let isActive = id => { + let active = XPIProvider.activeAddons.get(id); + return active && !active.disable; + }; + + if (aAddon.dependencies.some(id => !isActive(id))) + return false; + } + + if (AddonManager.checkCompatibility) { + if (!aAddon.isCompatible) { + logger.warn(`Add-on ${aAddon.id} is not compatible with application version.`); + return false; + } + } + else { + let app = aAddon.matchingTargetApplication; + if (!app) { + logger.warn(`Add-on ${aAddon.id} is not compatible with target application.`); + return false; + } + + // XXX Temporary solution to let applications opt-in to make themes safer + // following significant UI changes even if checkCompatibility=false has + // been set, until we get bug 962001. + if (aAddon.type == "theme" && app.id == Services.appinfo.ID) { + try { + let minCompatVersion = Services.prefs.getCharPref(PREF_CHECKCOMAT_THEMEOVERRIDE); + if (minCompatVersion && + Services.vc.compare(minCompatVersion, app.maxVersion) > 0) { + logger.warn(`Theme ${aAddon.id} is not compatible with application version.`); + return false; + } + } catch (e) {} + } + } + + 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, + multiprocessCompatible: aAddon.multiprocessCompatible, + mpcOptedOut: aAddon.mpcOptedOut, + runInSafeMode: aAddon.runInSafeMode, + dependencies: aAddon.dependencies, + hasEmbeddedWebExtension: aAddon.hasEmbeddedWebExtension, + }; +} + +/** + * Converts an internal add-on type to the type presented through the API. + * + * @param aType + * The internal add-on type + * @return an external add-on type + */ +function getExternalType(aType) { + if (aType in TYPE_ALIASES) + return TYPE_ALIASES[aType]; + return aType; +} + +function getManifestFileForDir(aDir) { + let file = aDir.clone(); + file.append(FILE_RDF_MANIFEST); + if (file.exists() && file.isFile()) + return file; + file.leafName = FILE_WEB_MANIFEST; + if (file.exists() && file.isFile()) + return file; + return null; +} + +function getManifestEntryForZipReader(aZipReader) { + if (aZipReader.hasEntry(FILE_RDF_MANIFEST)) + return FILE_RDF_MANIFEST; + if (aZipReader.hasEntry(FILE_WEB_MANIFEST)) + return FILE_WEB_MANIFEST; + return null; +} + +/** + * Converts a list of API types to a list of API types and any aliases for those + * types. + * + * @param aTypes + * An array of types or null for all types + * @return an array of types or null for all types + */ +function getAllAliasesForTypes(aTypes) { + if (!aTypes) + return null; + + // Build a set of all requested types and their aliases + let typeset = new Set(aTypes); + + for (let alias of Object.keys(TYPE_ALIASES)) { + // Ignore any requested internal types + typeset.delete(alias); + + // Add any alias for the internal type + if (typeset.has(TYPE_ALIASES[alias])) + typeset.add(alias); + } + + return [...typeset]; +} + +/** + * 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 a manifest stream. + * + * @param aUri + * A |file:| or |jar:| URL for the manifest + * @return an AddonInternal object + * @throws if the install manifest in the stream is corrupt or could not + * be read + */ +var loadManifestFromWebManifest = Task.async(function*(aUri) { + // We're passed the URI for the manifest file. Get the URI for its + // parent directory. + let uri = NetUtil.newURI("./", null, aUri); + + let extension = new ExtensionData(uri); + + let manifest = yield extension.readManifest(); + + // Read the list of available locales, and pre-load messages for + // all locales. + let locales = yield extension.initAllLocales(); + + // If there were any errors loading the extension, bail out now. + if (extension.errors.length) + throw new Error("Extension is invalid"); + + let bss = (manifest.browser_specific_settings && manifest.browser_specific_settings.gecko) + || (manifest.applications && manifest.applications.gecko) || {}; + if (manifest.browser_specific_settings && manifest.applications) { + logger.warn("Ignoring applications property in manifest"); + } + + // A * is illegal in strict_min_version + if (bss.strict_min_version && bss.strict_min_version.split(".").some(part => part == "*")) { + throw new Error("The use of '*' in strict_min_version is invalid"); + } + + let addon = new AddonInternal(); + addon.id = bss.id; + addon.version = manifest.version; + addon.type = "webextension"; + addon.unpack = false; + addon.strictCompatibility = true; + addon.bootstrap = true; + addon.hasBinaryComponents = false; + addon.multiprocessCompatible = true; + addon.internalName = null; + addon.updateURL = bss.update_url; + addon.updateKey = null; + addon.optionsURL = null; + addon.optionsType = null; + addon.aboutURL = null; + addon.dependencies = Object.freeze(Array.from(extension.dependencies)); + + if (manifest.options_ui) { + // Store just the relative path here, the AddonWrapper getURL + // wrapper maps this to a full URL. + addon.optionsURL = manifest.options_ui.page; + if (manifest.options_ui.open_in_tab) + addon.optionsType = AddonManager.OPTIONS_TYPE_TAB; + else + addon.optionsType = AddonManager.OPTIONS_TYPE_INLINE_BROWSER; + } + + // WebExtensions don't use iconURLs + addon.iconURL = null; + addon.icon64URL = null; + addon.icons = manifest.icons || {}; + + addon.applyBackgroundUpdates = AddonManager.AUTOUPDATE_DEFAULT; + + function getLocale(aLocale) { + // Use the raw manifest, here, since we need values with their + // localization placeholders still in place. + let rawManifest = extension.rawManifest; + + // As a convenience, allow author to be set if its a string bug 1313567. + let creator = typeof(rawManifest.author) === 'string' ? rawManifest.author : null; + let homepageURL = rawManifest.homepage_url; + + // Allow developer to override creator and homepage_url. + if (rawManifest.developer) { + if (rawManifest.developer.name) { + creator = rawManifest.developer.name; + } + if (rawManifest.developer.url) { + homepageURL = rawManifest.developer.url; + } + } + + let result = { + name: extension.localize(rawManifest.name, aLocale), + description: extension.localize(rawManifest.description, aLocale), + creator: extension.localize(creator, aLocale), + homepageURL: extension.localize(homepageURL, aLocale), + + developers: null, + translators: null, + contributors: null, + locales: [aLocale], + }; + return result; + } + + addon.defaultLocale = getLocale(extension.defaultLocale); + addon.locales = Array.from(locales.keys(), getLocale); + + delete addon.defaultLocale.locales; + + addon.targetApplications = [{ + id: TOOLKIT_ID, + minVersion: bss.strict_min_version, + maxVersion: bss.strict_max_version, + }]; + + addon.targetPlatforms = []; + addon.userDisabled = false; + addon.softDisabled = addon.blocklistState == Blocklist.STATE_SOFTBLOCKED; + + return addon; +}); + +/** + * 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 + */ +let loadManifestFromRDF = Task.async(function*(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; + } + } + + for (let prop of PROP_LOCALE_SINGLE) { + locale[prop] = getRDFProperty(aDs, aSource, prop); + } + + for (let prop of PROP_LOCALE_MULTI) { + // Don't store empty arrays + let props = getPropertyArray(aDs, aSource, + prop.substring(0, prop.length - 1)); + if (props.length > 0) + locale[prop] = 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(); + for (let prop of PROP_METADATA) { + addon[prop] = getRDFProperty(ds, root, prop); + } + 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"; + + let mpcValue = getRDFProperty(ds, root, "multiprocessCompatible"); + addon.multiprocessCompatible = mpcValue == "true"; + addon.mpcOptedOut = mpcValue == "false"; + + addon.hasEmbeddedWebExtension = getRDFProperty(ds, root, "hasEmbeddedWebExtension") == "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); + } + + if (addon.hasEmbeddedWebExtension) { + let uri = NetUtil.newURI("webextension/manifest.json", null, aUri); + let embeddedAddon = yield loadManifestFromWebManifest(uri); + if (embeddedAddon.optionsURL) { + if (addon.optionsType || addon.optionsURL) + logger.warn(`Addon ${addon.id} specifies optionsType or optionsURL ` + + `in both install.rdf and manifest.json`); + + addon.optionsURL = embeddedAddon.optionsURL; + addon.optionsType = embeddedAddon.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 dependencies = new Set(); + targets = ds.GetTargets(root, EM_R("dependency"), true); + while (targets.hasMoreElements()) { + let target = targets.getNext().QueryInterface(Ci.nsIRDFResource); + let id = getRDFProperty(ds, target, "id"); + dependencies.add(id); + } + addon.dependencies = Object.freeze(Array.from(dependencies)); + + let seenApplications = []; + addon.targetApplications = []; + targets = ds.GetTargets(root, EM_R("targetApplication"), true); + while (targets.hasMoreElements()) { + let target = targets.getNext().QueryInterface(Ci.nsIRDFResource); + let targetAppInfo = {}; + for (let prop of PROP_TARGETAPP) { + targetAppInfo[prop] = getRDFProperty(ds, target, prop); + } + 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 = []; + for (let targetPlatform of targetPlatforms) { + let platform = { + os: null, + abi: null + }; + + let pos = targetPlatform.indexOf("_"); + if (pos != -1) { + platform.os = targetPlatform.substring(0, pos); + platform.abi = targetPlatform.substring(pos + 1); + } + else { + platform.os = targetPlatform; + } + + 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; + } + else if (addon.type == "experiment") { + // Experiments are disabled by default. It is up to the Experiments Manager + // to enable them (it drives installation). + 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; + } + + // icons will be filled by the calling function + addon.icons = {}; + + return addon; +}); + +function defineSyncGUID(aAddon) { + // Define .syncGUID as a lazy property which is also settable + Object.defineProperty(aAddon, "syncGUID", { + get: () => { + // Generate random GUID used for Sync. + let guid = Cc["@mozilla.org/uuid-generator;1"] + .getService(Ci.nsIUUIDGenerator) + .generateUUID().toString(); + + delete aAddon.syncGUID; + aAddon.syncGUID = guid; + return guid; + }, + set: (val) => { + delete aAddon.syncGUID; + aAddon.syncGUID = val; + }, + configurable: true, + enumerable: true, + }); +} + +// Generate a unique ID based on the path to this temporary add-on location. +function generateTemporaryInstallID(aFile) { + const hasher = Cc["@mozilla.org/security/hash;1"] + .createInstance(Ci.nsICryptoHash); + hasher.init(hasher.SHA1); + const data = new TextEncoder().encode(aFile.path); + // Make it so this ID cannot be guessed. + const sess = TEMP_INSTALL_ID_GEN_SESSION; + hasher.update(sess, sess.length); + hasher.update(data, data.length); + let id = `${getHashStringForCrypto(hasher)}@temporary-addon`; + logger.info(`Generated temp id ${id} (${sess.join("")}) for ${aFile.path}`); + return id; +} + +/** + * 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 + */ +var loadManifestFromDir = Task.async(function*(aDir, aInstallLocation) { + 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; + } + + function* loadFromRDF(aUri) { + let fis = Cc["@mozilla.org/network/file-input-stream;1"]. + createInstance(Ci.nsIFileInputStream); + fis.init(aUri.file, -1, -1, false); + let bis = Cc["@mozilla.org/network/buffered-input-stream;1"]. + createInstance(Ci.nsIBufferedInputStream); + bis.init(fis, 4096); + try { + var addon = yield loadManifestFromRDF(aUri, bis); + } finally { + bis.close(); + fis.close(); + } + + let iconFile = aDir.clone(); + iconFile.append("icon.png"); + + if (iconFile.exists()) { + addon.icons[32] = "icon.png"; + addon.icons[48] = "icon.png"; + } + + let icon64File = aDir.clone(); + icon64File.append("icon64.png"); + + if (icon64File.exists()) { + addon.icons[64] = "icon64.png"; + } + + let file = aDir.clone(); + file.append("chrome.manifest"); + let chromeManifest = ChromeManifestParser.parseSync(Services.io.newFileURI(file)); + addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest, + "binary-component"); + return addon; + } + + let file = getManifestFileForDir(aDir); + if (!file) { + throw new Error("Directory " + aDir.path + " does not contain a valid " + + "install manifest"); + } + + let uri = Services.io.newFileURI(file).QueryInterface(Ci.nsIFileURL); + + let addon; + if (file.leafName == FILE_WEB_MANIFEST) { + addon = yield loadManifestFromWebManifest(uri); + if (!addon.id) { + if (aInstallLocation == TemporaryInstallLocation) { + addon.id = generateTemporaryInstallID(aDir); + } else { + addon.id = aDir.leafName; + } + } + } else { + addon = yield loadFromRDF(uri); + } + + addon._sourceBundle = aDir.clone(); + addon._installLocation = aInstallLocation; + addon.size = getFileSize(aDir); + addon.signedState = yield verifyDirSignedState(aDir, addon) + .then(({signedState}) => signedState); + addon.appDisabled = !isUsableAddon(addon); + + defineSyncGUID(addon); + + return addon; +}); + +/** + * 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 + */ +var loadManifestFromZipReader = Task.async(function*(aZipReader, aInstallLocation) { + function* loadFromRDF(aUri) { + let zis = aZipReader.getInputStream(entry); + let bis = Cc["@mozilla.org/network/buffered-input-stream;1"]. + createInstance(Ci.nsIBufferedInputStream); + bis.init(zis, 4096); + try { + var addon = yield loadManifestFromRDF(aUri, bis); + } finally { + bis.close(); + zis.close(); + } + + if (aZipReader.hasEntry("icon.png")) { + addon.icons[32] = "icon.png"; + addon.icons[48] = "icon.png"; + } + + if (aZipReader.hasEntry("icon64.png")) { + addon.icons[64] = "icon64.png"; + } + + // Binary components can only be loaded from unpacked addons. + if (addon.unpack) { + let uri = buildJarURI(aZipReader.file, "chrome.manifest"); + let chromeManifest = ChromeManifestParser.parseSync(uri); + addon.hasBinaryComponents = ChromeManifestParser.hasType(chromeManifest, + "binary-component"); + } else { + addon.hasBinaryComponents = false; + } + + return addon; + } + + let entry = getManifestEntryForZipReader(aZipReader); + if (!entry) { + throw new Error("File " + aZipReader.file.path + " does not contain a valid " + + "install manifest"); + } + + let uri = buildJarURI(aZipReader.file, entry); + + let isWebExtension = (entry == FILE_WEB_MANIFEST); + + let addon = isWebExtension ? + yield loadManifestFromWebManifest(uri) : + yield loadFromRDF(uri); + + addon._sourceBundle = aZipReader.file; + addon._installLocation = aInstallLocation; + + addon.size = 0; + let entries = aZipReader.findEntries(null); + while (entries.hasMore()) + addon.size += aZipReader.getEntry(entries.getNext()).realSize; + + let {signedState, cert} = yield verifyZipSignedState(aZipReader.file, addon); + addon.signedState = signedState; + if (isWebExtension && !addon.id) { + if (cert) { + addon.id = cert.commonName; + if (!gIDTest.test(addon.id)) { + throw new Error(`Webextension is signed with an invalid id (${addon.id})`); + } + } + if (!addon.id && aInstallLocation == TemporaryInstallLocation) { + addon.id = generateTemporaryInstallID(aZipReader.file); + } + } + addon.appDisabled = !isUsableAddon(addon); + + defineSyncGUID(addon); + + return addon; +}); + +/** + * 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 + */ +var loadManifestFromZipFile = Task.async(function*(aXPIFile, aInstallLocation) { + let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"]. + createInstance(Ci.nsIZipReader); + try { + zipReader.open(aXPIFile); + + // Can't return this promise because that will make us close the zip reader + // before it has finished loading the manifest. Wait for the result and then + // return. + let manifest = yield loadManifestFromZipReader(zipReader, aInstallLocation); + return manifest; + } + finally { + zipReader.close(); + } +}); + +function loadManifestFromFile(aFile, aInstallLocation) { + if (aFile.isFile()) + return loadManifestFromZipFile(aFile, aInstallLocation); + return loadManifestFromDir(aFile, aInstallLocation); +} + +/** + * A synchronous method for loading an add-on's manifest. This should only ever + * be used during startup or a sync load of the add-ons DB + */ +function syncLoadManifestFromFile(aFile, aInstallLocation) { + let success = undefined; + let result = null; + + loadManifestFromFile(aFile, aInstallLocation).then(val => { + success = true; + result = val; + }, val => { + success = false; + result = val + }); + + let thread = Services.tm.currentThread; + + while (success === undefined) + thread.processNextEvent(true); + + if (!success) + throw result; + return result; +} + +/** + * 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(part => resource.append(part)); + + 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; +} + +/** + * Returns the signedState for a given return code and certificate by verifying + * it against the expected ID. + */ +function getSignedStatus(aRv, aCert, aAddonID) { + let expectedCommonName = aAddonID; + if (aAddonID && aAddonID.length > 64) { + let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"]. + createInstance(Ci.nsIScriptableUnicodeConverter); + converter.charset = "UTF-8"; + let data = converter.convertToByteArray(aAddonID, {}); + + let crypto = Cc["@mozilla.org/security/hash;1"]. + createInstance(Ci.nsICryptoHash); + crypto.init(Ci.nsICryptoHash.SHA256); + crypto.update(data, data.length); + expectedCommonName = getHashStringForCrypto(crypto); + } + + switch (aRv) { + case Cr.NS_OK: + if (expectedCommonName && expectedCommonName != aCert.commonName) + return AddonManager.SIGNEDSTATE_BROKEN; + + let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined); + if (hotfixID && hotfixID == aAddonID && Preferences.get(PREF_EM_CERT_CHECKATTRIBUTES, false)) { + // The hotfix add-on has some more rigorous certificate checks + try { + CertUtils.validateCert(aCert, + CertUtils.readCertPrefs(PREF_EM_HOTFIX_CERTS)); + } + catch (e) { + logger.warn("The hotfix add-on was not signed by the expected " + + "certificate and so will not be installed.", e); + return AddonManager.SIGNEDSTATE_BROKEN; + } + } + + if (aCert.organizationalUnit == "Mozilla Components") + return AddonManager.SIGNEDSTATE_SYSTEM; + + return /preliminary/i.test(aCert.organizationalUnit) + ? AddonManager.SIGNEDSTATE_PRELIMINARY + : AddonManager.SIGNEDSTATE_SIGNED; + case Cr.NS_ERROR_SIGNED_JAR_NOT_SIGNED: + return AddonManager.SIGNEDSTATE_MISSING; + case Cr.NS_ERROR_SIGNED_JAR_MANIFEST_INVALID: + case Cr.NS_ERROR_SIGNED_JAR_ENTRY_INVALID: + case Cr.NS_ERROR_SIGNED_JAR_ENTRY_MISSING: + case Cr.NS_ERROR_SIGNED_JAR_ENTRY_TOO_LARGE: + case Cr.NS_ERROR_SIGNED_JAR_UNSIGNED_ENTRY: + case Cr.NS_ERROR_SIGNED_JAR_MODIFIED_ENTRY: + return AddonManager.SIGNEDSTATE_BROKEN; + default: + // Any other error indicates that either the add-on isn't signed or it + // is signed by a signature that doesn't chain to the trusted root. + return AddonManager.SIGNEDSTATE_UNKNOWN; + } +} + +function shouldVerifySignedState(aAddon) { + // Updated system add-ons should always have their signature checked + if (aAddon._installLocation.name == KEY_APP_SYSTEM_ADDONS) + return true; + + // We don't care about signatures for default system add-ons + if (aAddon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS) + return false; + + // Hotfixes should always have their signature checked + let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined); + if (hotfixID && aAddon.id == hotfixID) + return true; + + // Otherwise only check signatures if signing is enabled and the add-on is one + // of the signed types. + return ADDON_SIGNING && SIGNED_TYPES.has(aAddon.type); +} + +let gCertDB = Cc["@mozilla.org/security/x509certdb;1"] + .getService(Ci.nsIX509CertDB); + +/** + * Verifies that a zip file's contents are all correctly signed by an + * AMO-issued certificate + * + * @param aFile + * the xpi file to check + * @param aAddon + * the add-on object to verify + * @return a Promise that resolves to an object with properties: + * signedState: an AddonManager.SIGNEDSTATE_* constant + * cert: an nsIX509Cert + */ +function verifyZipSignedState(aFile, aAddon) { + if (!shouldVerifySignedState(aAddon)) + return Promise.resolve({ + signedState: AddonManager.SIGNEDSTATE_NOT_REQUIRED, + cert: null + }); + + let root = Ci.nsIX509CertDB.AddonsPublicRoot; + if (!REQUIRE_SIGNING && Preferences.get(PREF_XPI_SIGNATURES_DEV_ROOT, false)) + root = Ci.nsIX509CertDB.AddonsStageRoot; + + return new Promise(resolve => { + let callback = { + openSignedAppFileFinished: function(aRv, aZipReader, aCert) { + if (aZipReader) + aZipReader.close(); + resolve({ + signedState: getSignedStatus(aRv, aCert, aAddon.id), + cert: aCert + }); + } + }; + // This allows the certificate DB to get the raw JS callback object so the + // test code can pass through objects that XPConnect would reject. + callback.wrappedJSObject = callback; + + gCertDB.openSignedAppFileAsync(root, aFile, callback); + }); +} + +/** + * Verifies that a directory's contents are all correctly signed by an + * AMO-issued certificate + * + * @param aDir + * the directory to check + * @param aAddon + * the add-on object to verify + * @return a Promise that resolves to an object with properties: + * signedState: an AddonManager.SIGNEDSTATE_* constant + * cert: an nsIX509Cert + */ +function verifyDirSignedState(aDir, aAddon) { + if (!shouldVerifySignedState(aAddon)) + return Promise.resolve({ + signedState: AddonManager.SIGNEDSTATE_NOT_REQUIRED, + cert: null, + }); + + let root = Ci.nsIX509CertDB.AddonsPublicRoot; + if (!REQUIRE_SIGNING && Preferences.get(PREF_XPI_SIGNATURES_DEV_ROOT, false)) + root = Ci.nsIX509CertDB.AddonsStageRoot; + + return new Promise(resolve => { + let callback = { + verifySignedDirectoryFinished: function(aRv, aCert) { + resolve({ + signedState: getSignedStatus(aRv, aCert, aAddon.id), + cert: null, + }); + } + }; + // This allows the certificate DB to get the raw JS callback object so the + // test code can pass through objects that XPConnect would reject. + callback.wrappedJSObject = callback; + + gCertDB.verifySignedDirectoryAsync(root, aDir, callback); + }); +} + +/** + * Verifies that a bundle's contents are all correctly signed by an + * AMO-issued certificate + * + * @param aBundle + * the nsIFile for the bundle to check, either a directory or zip file + * @param aAddon + * the add-on object to verify + * @return a Promise that resolves to an AddonManager.SIGNEDSTATE_* constant. + */ +function verifyBundleSignedState(aBundle, aAddon) { + let promise = aBundle.isFile() ? verifyZipSignedState(aBundle, aAddon) + : verifyDirSignedState(aBundle, aAddon); + return promise.then(({signedState}) => signedState); +} + +/** + * 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) + throw e; + // 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() || aFile.isSymlink()) { + 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(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(); + } + } +} + +/** + * Record a bit of per-addon telemetry + * @param aAddon the addon to record + */ +function recordAddonTelemetry(aAddon) { + let locale = aAddon.defaultLocale; + if (locale) { + if (locale.name) + XPIProvider.setTelemetry(aAddon.id, "name", locale.name); + if (locale.creator) + XPIProvider.setTelemetry(aAddon.id, "creator", locale.creator); + } +} + +/** + * 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; + XPIProvider.setTelemetry(aId, "scan_items", items); + if (modTime != this.scanTime) { + this.scanTime = modTime; + changed = true; + } + } + // if the add-on is disabled, modified time is the install manifest time, if + // any. If no manifest exists, we assume this is a packed .xpi and use + // the time stamp of {path} + try { + // Get the install manifest update time, if any. + let maniFile = getManifestFileForDir(aFile); + 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; + } + } + // Record duration of file-modified check + XPIProvider.setTelemetry(aId, "scan_MS", Math.round(Cu.now() - scanStarted)); + + 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.getAddonLocations(); + // 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 [id, file] of addons) { + 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}); + } + else { + logger.debug("Existing add-on ${id} in ${location}", {id: id, location: location.name}); + } + foundAddons.set(id, xpiState); + } + XPIProvider.setTelemetry(id, "location", location.name); + } + + // 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); + XPIProvider.setTelemetry(aAddon.id, "location", aAddon.location); + }, + + /** + * 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() { + return "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 Map of active addons to their bootstrapScope by ID + activeAddons: new Map(), + // 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: {}, + // A Map from an add-on install to its ID + _addonFileMap: new Map(), + // Flag to know if ToolboxProcess.jsm has already been loaded by someone or not + _toolboxProcessLoaded: false, + // Have we started shutting down bootstrap add-ons? + _closing: false, + + /** + * Returns an array of the add-on values in `bootstrappedAddons`, + * sorted so that all of an add-on's dependencies appear in the array + * before itself. + * + * @returns {Array} + * A sorted array of add-on objects. Each value is a copy of the + * corresponding value in the `bootstrappedAddons` object, with an + * additional `id` property, which corresponds to the key in that + * object, which is the same as the add-ons ID. + */ + sortBootstrappedAddons: function() { + let addons = {}; + + // Sort the list of IDs so that the ordering is deterministic. + for (let id of Object.keys(this.bootstrappedAddons).sort()) { + addons[id] = Object.assign({id}, this.bootstrappedAddons[id]); + } + + let res = new Set(); + let seen = new Set(); + + let add = addon => { + seen.add(addon.id); + + for (let id of addon.dependencies || []) { + if (id in addons && !seen.has(id)) { + add(addons[id]); + } + } + + res.add(addon.id); + } + + Object.values(addons).forEach(add); + + return Array.from(res, id => addons[id]); + }, + + /* + * Set a value in the telemetry hash for a given ID + */ + setTelemetry: function(aId, aName, aValue) { + if (!this._telemetryDetails[aId]) + this._telemetryDetails[aId] = {}; + this._telemetryDetails[aId][aName] = aValue; + }, + + // Keep track of in-progress operations that support cancel() + _inProgress: [], + + doing: function(aCancellable) { + this._inProgress.push(aCancellable); + }, + + done: function(aCancellable) { + let i = this._inProgress.indexOf(aCancellable); + if (i != -1) { + this._inProgress.splice(i, 1); + return true; + } + return false; + }, + + cancelAll: function() { + // 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(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(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(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 = aLocked ? new DirectoryInstallLocation(aName, dir, aScope) + : new MutableDirectoryInstallLocation(aName, dir, aScope); + } + catch (e) { + logger.warn("Failed to add directory install location " + aName, e); + return; + } + + XPIProvider.installLocations.push(location); + XPIProvider.installLocationsByName[location.name] = location; + } + + function addSystemAddonInstallLocation(aName, aKey, aPaths, aScope) { + 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 SystemAddonInstallLocation(aName, dir, aScope, aAppChanged !== false); + } + catch (e) { + logger.warn("Failed to add system add-on 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 = new Set(); + 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 = {}; + // Register our details structure with AddonManager + AddonManagerPrivate.setTelemetryDetails("XPI", this._telemetryDetails); + + 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 + + XPIProvider.installLocations.push(TemporaryInstallLocation); + XPIProvider.installLocationsByName[TemporaryInstallLocation.name] = + TemporaryInstallLocation; + + // The profile location is always enabled + addDirectoryInstallLocation(KEY_APP_PROFILE, KEY_PROFILEDIR, + [DIR_EXTENSIONS], + AddonManager.SCOPE_PROFILE, false); + + addSystemAddonInstallLocation(KEY_APP_SYSTEM_ADDONS, KEY_PROFILEDIR, + [DIR_SYSTEM_ADDONS], + AddonManager.SCOPE_PROFILE); + + addDirectoryInstallLocation(KEY_APP_SYSTEM_DEFAULTS, KEY_APP_FEATURES, + [], AddonManager.SCOPE_PROFILE, true); + + 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); + } + } + + addDirectoryInstallLocation(KEY_APP_GLOBAL, KEY_ADDON_APP_DIR, + [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.prefs.addObserver(PREF_E10S_ADDON_BLOCKLIST, this, false); + Services.prefs.addObserver(PREF_E10S_ADDON_POLICY, this, false); + if (!REQUIRE_SIGNING) + Services.prefs.addObserver(PREF_XPI_SIGNATURES_REQUIRED, this, false); + Services.obs.addObserver(this, NOTIFICATION_FLUSH_PERMISSIONS, false); + + // Cu.isModuleLoaded can fail here for external XUL apps where there is + // no chrome.manifest that defines resource://devtools. + if (ResProtocolHandler.hasSubstitution("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); + } + } + + 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 && !this.allAppGlobal && + Preferences.get(PREF_EM_SHOW_MISMATCH_UI, true)) { + 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 addon of this.sortBootstrappedAddons()) { + try { + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.persistentDescriptor = addon.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(addon.id) !== -1) + reason = BOOTSTRAP_REASONS.ADDON_INSTALL; + this.callBootstrapMethod(createAddonDetails(addon.id, addon), + file, "startup", reason); + } + catch (e) { + logger.error("Failed to load bootstrap addon " + addon.id + " from " + + addon.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(aSubject, aTopic, aData) { + XPIProvider._closing = true; + for (let addon of XPIProvider.sortBootstrappedAddons().reverse()) { + // If no scope has been loaded for this add-on then there is no need + // to shut it down (should only happen when a bootstrapped add-on is + // pending enable) + if (!XPIProvider.activeAddons.has(addon.id)) + continue; + + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.persistentDescriptor = addon.descriptor; + let addonDetails = createAddonDetails(addon.id, addon); + + // If the add-on was pending disable then shut it down and remove it + // from the persisted data. + if (addon.disable) { + XPIProvider.callBootstrapMethod(addonDetails, file, "shutdown", + BOOTSTRAP_REASONS.ADDON_DISABLE); + delete XPIProvider.bootstrappedAddons[addon.id]; + } + else { + XPIProvider.callBootstrapMethod(addonDetails, 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(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; + + let timerManager = Cc["@mozilla.org/updates/timer-manager;1"]. + getService(Ci.nsIUpdateTimerManager); + timerManager.registerTimer("xpi-signature-verification", () => { + this.verifySignatures(); + }, XPI_SIGNATURE_CHECK_PERIOD); + } + 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() { + logger.debug("shutdown"); + + // Stop anything we were doing asynchronously + this.cancelAll(); + + this.bootstrappedAddons = {}; + this.activeAddons.clear(); + 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; + } + logger.debug("Notifying XPI shutdown observers"); + Services.obs.notifyObservers(null, "xpi-provider-shutdown", null); + return undefined; + }, + + /** + * Applies any pending theme change to the preferences. + */ + applyThemeChange: function() { + 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(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) && + !addon.isCompatible) { + 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(aAddonIDs) { + logger.debug("XPI_showUpgradeUI: " + aAddonIDs.toSource()); + Services.telemetry.getHistogramById("ADDON_MANAGER_UPGRADE_UI_SHOWN").add(1); + + // 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()); + }, + + updateSystemAddons: Task.async(function*() { + let systemAddonLocation = XPIProvider.installLocationsByName[KEY_APP_SYSTEM_ADDONS]; + if (!systemAddonLocation) + return; + + // Don't do anything in safe mode + if (Services.appinfo.inSafeMode) + return; + + // Download the list of system add-ons + let url = Preferences.get(PREF_SYSTEM_ADDON_UPDATE_URL, null); + if (!url) { + yield systemAddonLocation.cleanDirectories(); + return; + } + + url = UpdateUtils.formatUpdateURL(url); + + logger.info(`Starting system add-on update check from ${url}.`); + let res = yield ProductAddonChecker.getProductAddonList(url); + + // If there was no list then do nothing. + if (!res || !res.gmpAddons) { + logger.info("No system add-ons list was returned."); + yield systemAddonLocation.cleanDirectories(); + return; + } + + let addonList = new Map( + res.gmpAddons.map(spec => [spec.id, { spec, path: null, addon: null }])); + + let getAddonsInLocation = (location) => { + return new Promise(resolve => { + XPIDatabase.getAddonsInLocation(location, resolve); + }); + }; + + let setMatches = (wanted, existing) => { + if (wanted.size != existing.size) + return false; + + for (let [id, addon] of existing) { + let wantedInfo = wanted.get(id); + + if (!wantedInfo) + return false; + if (wantedInfo.spec.version != addon.version) + return false; + } + + return true; + }; + + // If this matches the current set in the profile location then do nothing. + let updatedAddons = addonMap(yield getAddonsInLocation(KEY_APP_SYSTEM_ADDONS)); + if (setMatches(addonList, updatedAddons)) { + logger.info("Retaining existing updated system add-ons."); + yield systemAddonLocation.cleanDirectories(); + return; + } + + // If this matches the current set in the default location then reset the + // updated set. + let defaultAddons = addonMap(yield getAddonsInLocation(KEY_APP_SYSTEM_DEFAULTS)); + if (setMatches(addonList, defaultAddons)) { + logger.info("Resetting system add-ons."); + systemAddonLocation.resetAddonSet(); + yield systemAddonLocation.cleanDirectories(); + return; + } + + // Download all the add-ons + let downloadAddon = Task.async(function*(item) { + try { + let sourceAddon = updatedAddons.get(item.spec.id); + if (sourceAddon && sourceAddon.version == item.spec.version) { + // Copying the file to a temporary location has some benefits. If the + // file is locked and cannot be read then we'll fall back to + // downloading a fresh copy. It also means we don't have to remember + // whether to delete the temporary copy later. + try { + let path = OS.Path.join(OS.Constants.Path.tmpDir, "tmpaddon"); + let unique = yield OS.File.openUnique(path); + unique.file.close(); + yield OS.File.copy(sourceAddon._sourceBundle.path, unique.path); + // Make sure to update file modification times so this is detected + // as a new add-on. + yield OS.File.setDates(unique.path); + item.path = unique.path; + } + catch (e) { + logger.warn(`Failed make temporary copy of ${sourceAddon._sourceBundle.path}.`, e); + } + } + if (!item.path) { + item.path = yield ProductAddonChecker.downloadAddon(item.spec); + } + item.addon = yield loadManifestFromFile(nsIFile(item.path), systemAddonLocation); + } + catch (e) { + logger.error(`Failed to download system add-on ${item.spec.id}`, e); + } + }); + yield Promise.all(Array.from(addonList.values()).map(downloadAddon)); + + // The download promises all resolve regardless, now check if they all + // succeeded + let validateAddon = (item) => { + if (item.spec.id != item.addon.id) { + logger.warn(`Downloaded system add-on expected to be ${item.spec.id} but was ${item.addon.id}.`); + return false; + } + + if (item.spec.version != item.addon.version) { + logger.warn(`Expected system add-on ${item.spec.id} to be version ${item.spec.version} but was ${item.addon.version}.`); + return false; + } + + if (!systemAddonLocation.isValidAddon(item.addon)) + return false; + + return true; + } + + if (!Array.from(addonList.values()).every(item => item.path && item.addon && validateAddon(item))) { + throw new Error("Rejecting updated system add-on set that either could not " + + "be downloaded or contained unusable add-ons."); + } + + // Install into the install location + logger.info("Installing new system add-on set"); + yield systemAddonLocation.installAddonSet(Array.from(addonList.values()) + .map(a => a.addon)); + }), + + /** + * Verifies that all installed add-ons are still correctly signed. + */ + verifySignatures: function() { + XPIDatabase.getAddonList(a => true, (addons) => { + Task.spawn(function*() { + let changes = { + enabled: [], + disabled: [] + }; + + for (let addon of addons) { + // The add-on might have vanished, we'll catch that on the next startup + if (!addon._sourceBundle.exists()) + continue; + + let signedState = yield verifyBundleSignedState(addon._sourceBundle, addon); + + if (signedState != addon.signedState) { + addon.signedState = signedState; + AddonManagerPrivate.callAddonListeners("onPropertyChanged", + addon.wrapper, + ["signedState"]); + } + + let disabled = XPIProvider.updateAddonDisabledState(addon); + if (disabled !== undefined) + changes[disabled ? "disabled" : "enabled"].push(addon.id); + } + + XPIDatabase.saveChanges(); + + Services.obs.notifyObservers(null, "xpi-signature-changed", JSON.stringify(changes)); + }).then(null, err => { + logger.error("XPI_verifySignature: " + err); + }) + }); + }, + + /** + * Persists changes to XPIProvider.bootstrappedAddons to its store (a pref). + */ + persistBootstrappedAddons: function() { + // 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() { + 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(aManifests) { + let changed = false; + for (let location of this.installLocations) { + aManifests[location.name] = {}; + // We can't install or uninstall anything in locked locations + if (location.locked) { + continue; + } + + let stagingDir = location.getStagingDir(); + + try { + if (!stagingDir || !stagingDir.exists() || !stagingDir.isDirectory()) + continue; + } + catch (e) { + logger.warn("Failed to find staging directory", e); + continue; + } + + 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) + throw 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. + 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 = getManifestFileForDir(stageDirEntry); + + // If the install manifest doesn't exist uninstall this add-on in this + // install location. + if (!manifest) { + logger.debug("Processing uninstall of " + id + " in " + location.name); + + try { + let addonFile = location.getLocationForID(id); + let addonToUninstall = syncLoadManifestFromFile(addonFile, location); + if (addonToUninstall.bootstrap) { + this.callBootstrapMethod(addonToUninstall, addonToUninstall._sourceBundle, + "uninstall", BOOTSTRAP_REASONS.ADDON_UNINSTALL); + } + } + catch (e) { + logger.warn("Failed to call uninstall for " + id, e); + } + + try { + location.uninstallAddon(id); + seenFiles.push(stageDirEntry.leafName); + } + catch (e) { + logger.error("Failed to uninstall add-on " + id + " in " + location.name, e); + } + // The file check later will spot the removal and cleanup the database + continue; + } + } + + aManifests[location.name][id] = null; + let existingAddonID = id; + + let jsonfile = stagingDir.clone(); + jsonfile.append(id + ".json"); + // Assume this was a foreign install if there is no cached metadata file + let foreignInstall = !jsonfile.exists(); + let addon; + + try { + addon = syncLoadManifestFromFile(stageDirEntry, location); + } + 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; + } + + if (mustSign(addon.type) && + addon.signedState <= AddonManager.SIGNEDSTATE_MISSING) { + logger.warn("Refusing to install staged add-on " + id + " with signed state " + addon.signedState); + 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 (!foreignInstall) { + logger.debug("Found updated metadata for " + id + " in " + location.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); + addon.importMetadata(metadata); + + // Pass this through to addMetadata so it knows this add-on was + // likely installed through the UI + aManifests[location.name][id] = addon; + } + 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 an error and continue + logger.error("Unable to read metadata from " + jsonfile.path, e); + } + finally { + fis.close(); + } + } + seenFiles.push(jsonfile.leafName); + + existingAddonID = addon.existingAddonID || id; + + var oldBootstrap = null; + logger.debug("Processing install of " + id + " in " + location.name); + if (existingAddonID in this.bootstrappedAddons) { + try { + var existingAddon = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + existingAddon.persistentDescriptor = this.bootstrappedAddons[existingAddonID].descriptor; + if (existingAddon.exists()) { + oldBootstrap = this.bootstrappedAddons[existingAddonID]; + + // We'll be replacing a currently active bootstrapped add-on so + // call its uninstall method + let newVersion = addon.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 { + addon._sourceBundle = location.installAddon({ + id, + source: stageDirEntry, + existingAddonID + }); + } + catch (e) { + logger.error("Failed to install staged add-on " + id + " in " + location.name, + e); + // Re-create the staged install + new StagedAddonInstall(location, stageDirEntry, addon); + // Make sure not to delete the cached manifest json file + seenFiles.pop(); + + delete aManifests[location.name][id]; + + if (oldBootstrap) { + // Re-install the old add-on + this.callBootstrapMethod(createAddonDetails(existingAddonID, oldBootstrap), + existingAddon, "install", + BOOTSTRAP_REASONS.ADDON_INSTALL); + } + continue; + } + } + + try { + location.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); + } + } + 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 + * @param aAppChanged + * See checkForChanges + * @return true if any new add-ons were installed + */ + installDistributionAddons: function(aManifests, aAppChanged) { + 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; + } + + /* If this is not an upgrade and we've already handled this extension + * just continue */ + if (!aAppChanged && Preferences.isSet(PREF_BRANCH_INSTALLED_ADDON + id)) { + continue; + } + + let addon; + try { + addon = syncLoadManifestFromFile(entry, profileLocation); + } + 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 = syncLoadManifestFromFile(existingEntry, profileLocation); + + 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 { + addon._sourceBundle = profileLocation.installAddon({ id, source: entry, action: "copy" }); + 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; + }, + + /** + * Imports the xpinstall permissions from preferences into the permissions + * manager for the user to change later. + */ + importPermissions: function() { + PermissionsUtils.importFromPrefs(PREF_XPI_PERMISSIONS_BRANCH, + XPI_PERMISSION); + }, + + getDependentAddons: function(aAddon) { + return Array.from(XPIDatabase.getAddons()) + .filter(addon => addon.dependencies.includes(aAddon.id)); + }, + + /** + * 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(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 (Preferences.get(PREF_INSTALL_DISTRO_ADDONS, true)) + { + updated = this.installDistributionAddons(manifests, aAppChanged); + 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(Object.keys(this.bootstrappedAddons) + .map(b => 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: " + + Array.from(bootstrapDescriptors).join(", ") + ")"); + 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 = XPIDatabaseReconcile.processFileChanges(manifests, + aAppChanged, + aOldAppVersion, + aOldPlatformVersion, + updateReasons.includes("schemaChanged")); + } + 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 + let oldCache = FileUtils.getFile(KEY_PROFILEDIR, [FILE_OLD_CACHE], true); + try { + 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(aMimetype) { + return aMimetype == "application/x-xpinstall"; + }, + + /** + * Called to test whether installing XPI add-ons is enabled. + * + * @return true if installing is enabled + */ + isInstallEnabled: function() { + // 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() { + // 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() { + // 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(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(aUrl, aHash, aName, aIcons, aVersion, aBrowser, + aCallback) { + createDownloadInstall(function(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(aFile, aCallback) { + createLocalInstall(aFile).then(install => { + aCallback(install ? install.wrapper : null); + }); + }, + + /** + * Temporarily installs add-on from a local XPI file or directory. + * As this is intended for development, the signature is not checked and + * the add-on does not persist on application restart. + * + * @param aFile + * An nsIFile for the unpacked add-on directory or XPI file. + * + * @return See installAddonFromLocation return value. + */ + installTemporaryAddon: function(aFile) { + return this.installAddonFromLocation(aFile, TemporaryInstallLocation); + }, + + /** + * Permanently installs add-on from a local XPI file or directory. + * The signature is checked but the add-on persist on application restart. + * + * @param aFile + * An nsIFile for the unpacked add-on directory or XPI file. + * + * @return See installAddonFromLocation return value. + */ + installAddonFromSources: Task.async(function*(aFile) { + let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE]; + return this.installAddonFromLocation(aFile, location, "proxy"); + }), + + /** + * Installs add-on from a local XPI file or directory. + * + * @param aFile + * An nsIFile for the unpacked add-on directory or XPI file. + * @param aInstallLocation + * Define a custom install location object to use for the install. + * @param aInstallAction + * Optional action mode to use when installing the addon + * (see MutableDirectoryInstallLocation.installAddon) + * + * @return a Promise that resolves to an Addon object on success, or rejects + * if the add-on is not a valid restartless add-on or if the + * same ID is already installed. + */ + installAddonFromLocation: Task.async(function*(aFile, aInstallLocation, aInstallAction) { + if (aFile.exists() && aFile.isFile()) { + flushJarCache(aFile); + } + let addon = yield loadManifestFromFile(aFile, aInstallLocation); + + aInstallLocation.installAddon({ id: addon.id, source: aFile, action: aInstallAction }); + + if (addon.appDisabled) { + let message = `Add-on ${addon.id} is not compatible with application version.`; + + let app = addon.matchingTargetApplication; + if (app) { + if (app.minVersion) { + message += ` add-on minVersion: ${app.minVersion}.`; + } + if (app.maxVersion) { + message += ` add-on maxVersion: ${app.maxVersion}.`; + } + } + throw new Error(message); + } + + if (!addon.bootstrap) { + throw new Error("Only restartless (bootstrap) add-ons" + + " can be installed from sources:", addon.id); + } + let installReason = BOOTSTRAP_REASONS.ADDON_INSTALL; + let oldAddon = yield new Promise( + resolve => XPIDatabase.getVisibleAddonForID(addon.id, resolve)); + if (oldAddon) { + if (!oldAddon.bootstrap) { + logger.warn("Non-restartless Add-on is already installed", addon.id); + throw new Error("Non-restartless add-on with ID " + + oldAddon.id + " is already installed"); + } + else { + logger.warn("Addon with ID " + oldAddon.id + " already installed," + + " older version will be disabled"); + + let existingAddonID = oldAddon.id; + let existingAddon = oldAddon._sourceBundle; + + // We'll be replacing a currently active bootstrapped add-on so + // call its uninstall method + let newVersion = addon.version; + let oldVersion = oldAddon.version; + if (Services.vc.compare(newVersion, oldVersion) >= 0) { + installReason = BOOTSTRAP_REASONS.ADDON_UPGRADE; + } else { + installReason = BOOTSTRAP_REASONS.ADDON_DOWNGRADE; + } + let uninstallReason = installReason; + + if (oldAddon.active) { + XPIProvider.callBootstrapMethod(oldAddon, existingAddon, + "shutdown", uninstallReason, + { newVersion }); + } + this.callBootstrapMethod(oldAddon, existingAddon, + "uninstall", uninstallReason, { newVersion }); + this.unloadBootstrapScope(existingAddonID); + flushChromeCaches(); + } + } + + let file = addon._sourceBundle; + + XPIProvider._addURIMapping(addon.id, file); + XPIProvider.callBootstrapMethod(addon, file, "install", installReason); + addon.state = AddonManager.STATE_INSTALLED; + logger.debug("Install of temporary addon in " + aFile.path + " completed."); + addon.visible = true; + addon.enabled = true; + addon.active = true; + + addon = XPIDatabase.addAddonMetadata(addon, file.persistentDescriptor); + + XPIStates.addAddon(addon); + XPIDatabase.saveChanges(); + XPIStates.save(); + + AddonManagerPrivate.callAddonListeners("onInstalling", addon.wrapper, + false); + XPIProvider.callBootstrapMethod(addon, file, "startup", + BOOTSTRAP_REASONS.ADDON_ENABLE); + AddonManagerPrivate.callInstallListeners("onExternalInstall", + null, addon.wrapper, + oldAddon ? oldAddon.wrapper : null, + false); + AddonManagerPrivate.callAddonListeners("onInstalled", addon.wrapper); + + return addon.wrapper; + }), + + /** + * Returns an Addon corresponding to an instance ID. + * @param aInstanceID + * An Addon Instance ID + * @return {Promise} + * @resolves The found Addon or null if no such add-on exists. + * @rejects Never + * @throws if the aInstanceID argument is not specified + */ + getAddonByInstanceID: function(aInstanceID) { + if (!aInstanceID || typeof aInstanceID != "symbol") + throw Components.Exception("aInstanceID must be a Symbol()", + Cr.NS_ERROR_INVALID_ARG); + + for (let [id, val] of this.activeAddons) { + if (aInstanceID == val.instanceID) { + if (val.safeWrapper) { + return Promise.resolve(val.safeWrapper); + } + + return new Promise(resolve => { + this.getAddonByID(id, function(addon) { + val.safeWrapper = new PrivateWrapper(addon); + resolve(val.safeWrapper); + }); + }); + } + } + + return Promise.resolve(null); + }, + + /** + * Removes an AddonInstall from the list of active installs. + * + * @param install + * The AddonInstall to remove + */ + removeActiveInstall: function(aInstall) { + this.installs.delete(aInstall); + }, + + /** + * 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(aId, aCallback) { + XPIDatabase.getVisibleAddonForID (aId, function(aAddon) { + aCallback(aAddon ? aAddon.wrapper : null); + }); + }, + + /** + * 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(aTypes, aCallback) { + let typesToGet = getAllAliasesForTypes(aTypes); + + XPIDatabase.getVisibleAddons(typesToGet, function(aAddons) { + aCallback(aAddons.map(a => a.wrapper)); + }); + }, + + /** + * 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(aGUID, aCallback) { + XPIDatabase.getAddonBySyncGUID(aGUID, function(aAddon) { + aCallback(aAddon ? aAddon.wrapper : null); + }); + }, + + /** + * 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(aTypes, aCallback) { + let typesToGet = getAllAliasesForTypes(aTypes); + + XPIDatabase.getVisibleAddonsWithPendingOperations(typesToGet, function(aAddons) { + let results = aAddons.map(a => a.wrapper); + for (let install of XPIProvider.installs) { + if (install.state == AddonManager.STATE_INSTALLED && + !(install.addon.inDatabase)) + results.push(install.addon.wrapper); + } + 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(aTypes, aCallback) { + let results = [...this.installs]; + if (aTypes) { + results = results.filter(install => { + return aTypes.includes(getExternalType(install.type)); + }); + } + + aCallback(results.map(install => install.wrapper)); + }, + + /** + * 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(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(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"); + for (let theme of addons) { + if (!theme.visible) + return; + if (theme.id == aId) + newSkin = theme.internalName; + else if (theme.userDisabled == false && !theme.pendingUninstall) + previousTheme = theme; + } + + 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() { + let addons = XPIDatabase.getAddons(); + for (let addon of addons) { + this.updateAddonDisabledState(addon); + } + }, + + /** + * Update the repositoryAddon property for all add-ons. + * + * @param aCallback + * Function to call when operation is complete. + */ + updateAddonRepositoryData: function(aCallback) { + XPIDatabase.getVisibleAddons(null, 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, aRepoAddon => { + if (aRepoAddon) { + logger.debug("updateAddonRepositoryData got info for " + addon.id); + addon._repositoryAddon = aRepoAddon; + addon.compatibilityOverrides = aRepoAddon.compatibilityOverrides; + this.updateAddonDisabledState(addon); + } + + notifyComplete(); + }); + } + }); + }, + + /** + * When the previously selected theme is removed this method will be called + * to enable the default theme. + */ + enableDefaultTheme: function() { + 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, val] of this.activeAddons) { + aConnection.setAddonOptions( + id, { global: val.debugGlobal || val.bootstrapScope }); + } + }, + + /** + * Notified when a preference we're interested in has changed. + * + * @see nsIObserver + */ + observe: function(aSubject, aTopic, aData) { + if (aTopic == NOTIFICATION_FLUSH_PERMISSIONS) { + if (!aData || aData == XPI_PERMISSION) { + this.importPermissions(); + } + return; + } + else if (aTopic == NOTIFICATION_TOOLBOXPROCESS_LOADED) { + Services.obs.removeObserver(this, NOTIFICATION_TOOLBOXPROCESS_LOADED, false); + this._toolboxProcessLoaded = true; + BrowserToolboxProcess.on("connectionchange", + this.onDebugConnectionChange.bind(this)); + } + + if (aTopic == "nsPref:changed") { + switch (aData) { + case PREF_EM_MIN_COMPAT_APP_VERSION: + this.minCompatibleAppVersion = Preferences.get(PREF_EM_MIN_COMPAT_APP_VERSION, + null); + this.updateAddonAppDisabledStates(); + break; + case PREF_EM_MIN_COMPAT_PLATFORM_VERSION: + this.minCompatiblePlatformVersion = Preferences.get(PREF_EM_MIN_COMPAT_PLATFORM_VERSION, + null); + this.updateAddonAppDisabledStates(); + break; + case PREF_XPI_SIGNATURES_REQUIRED: + this.updateAddonAppDisabledStates(); + break; + + case PREF_E10S_ADDON_BLOCKLIST: + case PREF_E10S_ADDON_POLICY: + XPIDatabase.updateAddonsBlockingE10s(); + break; + } + } + }, + + /** + * Determine if an add-on should be blocking e10s if enabled. + * + * @param aAddon + * The add-on to test + * @return true if enabling the add-on should block e10s + */ + isBlockingE10s: function(aAddon) { + if (aAddon.type != "extension" && + aAddon.type != "webextension" && + aAddon.type != "theme") + return false; + + // The hotfix is exempt + let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined); + if (hotfixID && hotfixID == aAddon.id) + return false; + + // The default theme is exempt + if (aAddon.type == "theme" && + aAddon.internalName == XPIProvider.defaultSkin) + return false; + + // System add-ons are exempt + let locName = aAddon._installLocation ? aAddon._installLocation.name + : undefined; + if (locName == KEY_APP_SYSTEM_DEFAULTS || + locName == KEY_APP_SYSTEM_ADDONS) + return false; + + if (isAddonPartOfE10SRollout(aAddon)) { + Preferences.set(PREF_E10S_HAS_NONEXEMPT_ADDON, true); + return false; + } + + logger.debug("Add-on " + aAddon.id + " blocks e10s rollout."); + return true; + }, + + /** + * In some cases having add-ons active blocks e10s but turning off e10s + * requires a restart so some add-ons that are normally restartless will + * require a restart to install or enable. + * + * @param aAddon + * The add-on to test + * @return true if enabling the add-on requires a restart + */ + e10sBlocksEnabling: function(aAddon) { + // If the preference isn't set then don't block anything + if (!Preferences.get(PREF_E10S_BLOCK_ENABLE, false)) + return false; + + // If e10s isn't active then don't block anything + if (!Services.appinfo.browserTabsRemoteAutostart) + return false; + + return this.isBlockingE10s(aAddon); + }, + + /** + * 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(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; + } + + if (this.e10sBlocksEnabling(aAddon)) + return true; + + 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(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(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; + + if (this.e10sBlocksEnabling(aAddon)) + return true; + + // 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(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. + * @param aRunInSafeMode + * Boolean indicating whether the add-on can run in safe mode. + * @param aDependencies + * An array of add-on IDs on which this add-on depends. + * @param hasEmbeddedWebExtension + * Boolean indicating whether the add-on has an embedded webextension. + * @return a JavaScript scope + */ + loadBootstrapScope: function(aId, aFile, aVersion, aType, + aMultiprocessCompatible, aRunInSafeMode, + aDependencies, hasEmbeddedWebExtension) { + // Mark the add-on as active for the crash reporter before loading + this.bootstrappedAddons[aId] = { + version: aVersion, + type: aType, + descriptor: aFile.persistentDescriptor, + multiprocessCompatible: aMultiprocessCompatible, + runInSafeMode: aRunInSafeMode, + dependencies: aDependencies, + hasEmbeddedWebExtension, + }; + this.persistBootstrappedAddons(); + this.addAddonsToCrashReporter(); + + this.activeAddons.set(aId, { + debugGlobal: null, + safeWrapper: null, + bootstrapScope: null, + // a Symbol passed to this add-on, which it can use to identify itself + instanceID: Symbol(aId), + }); + let activeAddon = this.activeAddons.get(aId); + + // Locales only contain chrome and can't have bootstrap scripts + if (aType == "locale") { + 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); + Cu.allowCPOWsInAddon(aId, true); + } + + if (!aFile.exists()) { + activeAddon.bootstrapScope = + 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" + else if (aType == "webextension") + uri = "resource://gre/modules/addons/WebExtensionBootstrap.js" + else if (aType == "apiextension") + uri = "resource://gre/modules/addons/APIExtensionBootstrap.js" + + activeAddon.bootstrapScope = + 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) + activeAddon.bootstrapScope[name] = BOOTSTRAP_REASONS[name]; + + // Add other stuff that extensions want. + const features = [ "Worker", "ChromeWorker" ]; + + for (let feature of features) + activeAddon.bootstrapScope[feature] = gGlobalScope[feature]; + + // Define a console for the add-on + activeAddon.bootstrapScope["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. + activeAddon.bootstrapScope.__SCRIPT_URI_SPEC__ = uri; + Components.utils.evalInSandbox( + "Components.classes['@mozilla.org/moz/jssubscript-loader;1'] \ + .createInstance(Components.interfaces.mozIJSSubScriptLoader) \ + .loadSubScript(__SCRIPT_URI_SPEC__);", + activeAddon.bootstrapScope, "ECMAv5"); + } + catch (e) { + logger.warn("Error loading bootstrap.js for " + aId, e); + } + + // 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: activeAddon.bootstrapScope }); + } + }, + + /** + * 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(aId) { + // In case the add-on was not multiprocess-compatible, deregister + // any interpositions for it. + Cu.setAddonInterposition(aId, null); + Cu.allowCPOWsInAddon(aId, false); + + this.activeAddons.delete(aId); + delete this.bootstrappedAddons[aId]; + this.persistBootstrappedAddons(); + this.addAddonsToCrashReporter(); + + // 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 }); + } + }, + + /** + * 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(aAddon, aFile, aMethod, aReason, aExtraParams) { + if (!aAddon.id || !aAddon.version || !aAddon.type) { + throw new Error("aAddon must include an id, version, and type"); + } + + // Only run in safe mode if allowed to + let runInSafeMode = "runInSafeMode" in aAddon ? aAddon.runInSafeMode : canRunInSafeMode(aAddon); + if (Services.appinfo.inSafeMode && !runInSafeMode) + return; + + let timeStart = new Date(); + if (CHROME_TYPES.has(aAddon.type) && aMethod == "startup") { + logger.debug("Registering manifest for " + aFile.path); + Components.manager.addBootstrappedManifestLocation(aFile); + } + + try { + // Load the scope if it hasn't already been loaded + let activeAddon = this.activeAddons.get(aAddon.id); + if (!activeAddon) { + this.loadBootstrapScope(aAddon.id, aFile, aAddon.version, aAddon.type, + aAddon.multiprocessCompatible || false, + runInSafeMode, aAddon.dependencies, + aAddon.hasEmbeddedWebExtension || false); + activeAddon = this.activeAddons.get(aAddon.id); + } + + if (aMethod == "startup" || aMethod == "shutdown") { + if (!aExtraParams) { + aExtraParams = {}; + } + aExtraParams["instanceID"] = this.activeAddons.get(aAddon.id).instanceID; + } + + // Nothing to call for locales + if (aAddon.type == "locale") + return; + + let method = undefined; + try { + method = Components.utils.evalInSandbox(`${aMethod};`, + activeAddon.bootstrapScope, "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; + } + + // Extensions are automatically deinitialized in the correct order at shutdown. + if (aMethod == "shutdown" && aReason != BOOTSTRAP_REASONS.APP_SHUTDOWN) { + activeAddon.disable = true; + for (let addon of this.getDependentAddons(aAddon)) { + if (addon.active) + this.updateAddonDisabledState(addon); + } + } + + 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]; + } + } + + if (aAddon.hasEmbeddedWebExtension) { + if (aMethod == "startup") { + const webExtension = LegacyExtensionsUtils.getEmbeddedExtensionFor(params); + params.webExtension = { + startup: () => webExtension.startup(), + }; + } else if (aMethod == "shutdown") { + LegacyExtensionsUtils.getEmbeddedExtensionFor(params).shutdown(); + } + } + + 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 { + // Extensions are automatically initialized in the correct order at startup. + if (aMethod == "startup" && aReason != BOOTSTRAP_REASONS.APP_STARTUP) { + for (let addon of this.getDependentAddons(aAddon)) + this.updateAddonDisabledState(addon); + } + + if (CHROME_TYPES.has(aAddon.type) && 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); + } + } + } + this.setTelemetry(aAddon.id, aMethod + "_MS", new Date() - timeStart); + } + }, + + /** + * 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 + * @return a tri-state indicating the action taken for the add-on: + * - undefined: The add-on did not change state + * - true: The add-on because disabled + * - false: The add-on became enabled + * @throws if addon is not a DBAddonInternal + */ + updateAddonDisabledState: function(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 undefined; + + 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. + XPIDatabase.setAddonProperties(aAddon, { + userDisabled: aUserDisabled, + appDisabled: appDisabled, + softDisabled: aSoftDisabled + }); + + let wrapper = aAddon.wrapper; + + if (appDisabledChanged) { + AddonManagerPrivate.callAddonListeners("onPropertyChanged", + wrapper, + ["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 undefined; + + // Flag that active states in the database need to be updated on shutdown + Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true); + + // 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) { + this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "shutdown", + BOOTSTRAP_REASONS.ADDON_DISABLE); + this.unloadBootstrapScope(aAddon.id); + } + AddonManagerPrivate.callAddonListeners("onDisabled", wrapper); + } + else { + if (aAddon.bootstrap) { + this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "startup", + BOOTSTRAP_REASONS.ADDON_ENABLE); + } + AddonManagerPrivate.callAddonListeners("onEnabled", wrapper); + } + } + else if (aAddon.bootstrap) { + // Something blocked the restartless add-on from enabling or disabling + // make sure it happens on the next startup + if (isDisabled) { + this.bootstrappedAddons[aAddon.id].disable = true; + } + else { + this.bootstrappedAddons[aAddon.id] = { + version: aAddon.version, + type: aAddon.type, + descriptor: aAddon._sourceBundle.persistentDescriptor, + multiprocessCompatible: aAddon.multiprocessCompatible, + runInSafeMode: canRunInSafeMode(aAddon), + dependencies: aAddon.dependencies, + hasEmbeddedWebExtension: aAddon.hasEmbeddedWebExtension, + }; + this.persistBootstrappedAddons(); + } + } + } + + // 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); + + return isDisabled; + }, + + /** + * 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(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"); + + aAddon._hasResourceCache.clear(); + + 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. Temporary add-ons are + // automatically uninstalled on shutdown anyway so there is no need to + // do this for them. + if (aAddon._installLocation.name != KEY_APP_TEMPORARY) { + 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 = aAddon.wrapper; + + // 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 = aAddon.wrapper; + AddonManagerPrivate.callAddonListeners("onInstalling", wrappedAddon, false); + + if (!aAddon.disabled && !XPIProvider.enableRequiresRestart(aAddon)) { + XPIDatabase.updateAddonActive(aAddon, true); + } + + if (aAddon.bootstrap) { + XPIProvider.callBootstrapMethod(aAddon, aAddon._sourceBundle, + "install", BOOTSTRAP_REASONS.ADDON_INSTALL); + + if (aAddon.active) { + XPIProvider.callBootstrapMethod(aAddon, aAddon._sourceBundle, + "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) { + if (aAddon.active) { + this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "shutdown", + BOOTSTRAP_REASONS.ADDON_UNINSTALL); + } + + this.callBootstrapMethod(aAddon, aAddon._sourceBundle, "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(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"); + + if (aAddon._installLocation.name != KEY_APP_TEMPORARY) + 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 = aAddon.wrapper; + 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(); +} + +/** + * Base class for objects that manage the installation of an addon. + * This class isn't instantiated directly, see the derived classes below. + */ +class AddonInstall { + /** + * 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 aExistingAddon + * The add-on this install will update if known + */ + constructor(aInstallLocation, aUrl, aHash, aExistingAddon) { + this.wrapper = new AddonInstallWrapper(this); + this.installLocation = aInstallLocation; + this.sourceURI = aUrl; + + if (aHash) { + let hashSplit = aHash.toLowerCase().split(":"); + this.originalHash = { + algorithm: hashSplit[0], + data: hashSplit[1] + }; + } + this.hash = this.originalHash; + this.existingAddon = aExistingAddon; + this.releaseNotesURI = null; + + this.listeners = []; + this.icons = {}; + this.error = 0; + + this.progress = 0; + this.maxProgress = -1; + + // Giving each instance of AddonInstall a reference to the logger. + this.logger = logger; + + this.name = null; + this.type = null; + this.version = null; + + this.file = null; + this.ownsTempFile = null; + this.certificate = null; + this.certName = null; + + this.linkedInstalls = null; + this.addon = null; + this.state = null; + + XPIProvider.installs.add(this); + } + + /** + * Starts installation of this add-on from whatever state it is currently at + * if possible. + * + * Note this method is overridden to handle additional state in + * the subclassses below. + * + * @throws if installation cannot proceed from the current state + */ + install() { + switch (this.state) { + case AddonManager.STATE_DOWNLOADED: + this.startInstall(); + break; + case AddonManager.STATE_POSTPONED: + logger.debug(`Postponing install of ${this.addon.id}`); + 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. + * + * Note this method is overridden to handle additional state in + * the subclass DownloadAddonInstall. + * + * @throws if installation cannot be cancelled from the current state + */ + cancel() { + switch (this.state) { + 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", this.addon.wrapper); + + AddonManagerPrivate.callInstallListeners("onInstallCancelled", + this.listeners, this.wrapper); + break; + case AddonManager.STATE_POSTPONED: + logger.debug(`Cancelling postponed install of ${this.addon.id}`); + this.state = AddonManager.STATE_CANCELLED; + XPIProvider.removeActiveInstall(this); + AddonManagerPrivate.callInstallListeners("onInstallCancelled", + this.listeners, this.wrapper); + this.removeTemporaryFile(); + + let stagingDir = this.installLocation.getStagingDir(); + let stagedAddon = stagingDir.clone(); + + this.unstageInstall(stagedAddon); + 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(aListener) { + if (!this.listeners.some(function(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(aListener) { + this.listeners = this.listeners.filter(function(i) { + return i != aListener; + }); + } + + /** + * Removes the temporary file owned by this AddonInstall if there is one. + */ + 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() { + this.addon.sourceURI = this.sourceURI.spec; + if (this.releaseNotesURI) + this.addon.releaseNotesURI = this.releaseNotesURI.spec; + } + + /** + * Fills out linkedInstalls with AddonInstall instances for the other files + * in a multi-package XPI. + * + * @param aFiles + * An array of { entryName, file } for each remaining file from the + * multi-package XPI. + */ + _createLinkedInstalls(aFiles) { + return Task.spawn((function*() { + if (aFiles.length == 0) + return; + + // Create new AddonInstall instances for every remaining file + if (!this.linkedInstalls) + this.linkedInstalls = []; + + for (let { entryName, file } of aFiles) { + logger.debug("Creating linked install from " + entryName); + let install = yield createLocalInstall(file); + + // Make the new install own its temporary file + install.ownsTempFile = true; + + this.linkedInstalls.push(install); + + // If one of the internal XPIs was multipackage then move its linked + // installs to the outer install + if (install.linkedInstalls) { + this.linkedInstalls.push(...install.linkedInstalls); + install.linkedInstalls = null; + } + + install.sourceURI = this.sourceURI; + install.releaseNotesURI = this.releaseNotesURI; + if (install.state != AddonManager.STATE_DOWNLOAD_FAILED) + install.updateAddonURIs(); + } + }).bind(this)); + } + + /** + * 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. + */ + _loadMultipackageManifests(aZipReader) { + return Task.spawn((function*() { + let files = []; + let entries = aZipReader.findEntries("(*.[Xx][Pp][Ii]|*.[Jj][Aa][Rr])"); + while (entries.hasMore()) { + let entryName = entries.getNext(); + let file = getTemporaryFile(); + try { + aZipReader.extract(entryName, file); + files.push({ entryName, file }); + } + catch (e) { + logger.warn("Failed to extract " + entryName + " from multi-package " + + "XPI", e); + file.remove(false); + } + } + + aZipReader.close(); + + if (files.length == 0) { + return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, + "Multi-package XPI does not contain any packages to install"]); + } + + let addon = null; + + // Find the first file that is a valid install and use it for + // the add-on that this AddonInstall instance will install. + for (let { entryName, file } of files) { + this.removeTemporaryFile(); + try { + yield this.loadManifest(file); + logger.debug("Base multi-package XPI install came from " + entryName); + this.file = file; + this.ownsTempFile = true; + + yield this._createLinkedInstalls(files.filter(f => f.file != file)); + return undefined; + } + catch (e) { + // _createLinkedInstalls will log errors when it tries to process this + // file + } + } + + // No valid add-on was found, delete all the temporary files + for (let { file } of files) { + try { + file.remove(true); + } catch (e) { + this.logger.warn("Could not remove temp file " + file.path); + } + } + + return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, + "Multi-package XPI does not contain any valid packages to install"]); + }).bind(this)); + } + + /** + * 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(file) { + return Task.spawn((function*() { + let zipreader = Cc["@mozilla.org/libjar/zip-reader;1"]. + createInstance(Ci.nsIZipReader); + try { + zipreader.open(file); + } + catch (e) { + zipreader.close(); + return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, e]); + } + + try { + // loadManifestFromZipReader performs the certificate verification for us + this.addon = yield loadManifestFromZipReader(zipreader, this.installLocation); + } + catch (e) { + zipreader.close(); + return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, e]); + } + + // A multi-package XPI is a container, the add-ons it holds each + // have their own id. Everything else had better have an id here. + if (!this.addon.id && this.addon.type != "multipackage") { + let err = new Error(`Cannot find id for addon ${file.path}`); + return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, err]); + } + + if (this.existingAddon) { + // Check various conditions related to upgrades + if (this.addon.id != this.existingAddon.id) { + zipreader.close(); + return Promise.reject([AddonManager.ERROR_INCORRECT_ID, + `Refusing to upgrade addon ${this.existingAddon.id} to different ID {this.addon.id}`]); + } + + if (this.addon.type == "multipackage") { + zipreader.close(); + return Promise.reject([AddonManager.ERROR_UNEXPECTED_ADDON_TYPE, + `Refusing to upgrade addon ${this.existingAddon.id} to a multi-package xpi`]); + } + + if (this.existingAddon.type == "webextension" && this.addon.type != "webextension") { + zipreader.close(); + return Promise.reject([AddonManager.ERROR_UNEXPECTED_ADDON_TYPE, + "WebExtensions may not be upated to other extension types"]); + } + } + + if (mustSign(this.addon.type)) { + if (this.addon.signedState <= AddonManager.SIGNEDSTATE_MISSING) { + // This add-on isn't properly signed by a signature that chains to the + // trusted root. + let state = this.addon.signedState; + this.addon = null; + zipreader.close(); + + if (state == AddonManager.SIGNEDSTATE_MISSING) + return Promise.reject([AddonManager.ERROR_SIGNEDSTATE_REQUIRED, + "signature is required but missing"]) + + return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, + "signature verification failed"]) + } + } + else if (this.addon.signedState == AddonManager.SIGNEDSTATE_UNKNOWN || + this.addon.signedState == AddonManager.SIGNEDSTATE_NOT_REQUIRED) { + // Check object signing certificate, if any + 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(); + return Promise.reject([AddonManager.ERROR_CORRUPT_FILE, + "XPI is incorrectly signed"]); + } + } + } + + if (this.addon.type == "multipackage") + return this._loadMultipackageManifests(zipreader); + + zipreader.close(); + + this.updateAddonURIs(); + + this.addon._install = this; + this.name = this.addon.selectedLocale.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. + + // Try to load from the existing cache first + let repoAddon = yield new Promise(resolve => AddonRepository.getCachedAddonByID(this.addon.id, resolve)); + + // It wasn't there so try to re-download it + if (!repoAddon) { + yield new Promise(resolve => AddonRepository.cacheAddons([this.addon.id], resolve)); + repoAddon = yield new Promise(resolve => AddonRepository.getCachedAddonByID(this.addon.id, resolve)); + } + + this.addon._repositoryAddon = repoAddon; + this.name = this.name || this.addon._repositoryAddon.name; + this.addon.compatibilityOverrides = repoAddon ? + repoAddon.compatibilityOverrides : + null; + this.addon.appDisabled = !isUsableAddon(this.addon); + return undefined; + }).bind(this)); + } + + // 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() { + 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", + this.addon.wrapper, + requiresRestart); + + let stagedAddon = this.installLocation.getStagingDir(); + + Task.spawn((function*() { + let installedUnpacked = 0; + + yield this.installLocation.requestStagingDir(); + + // remove any previously staged files + yield this.unstageInstall(stagedAddon); + + stagedAddon.append(this.addon.id); + stagedAddon.leafName = this.addon.id + ".xpi"; + + installedUnpacked = yield this.stageInstall(requiresRestart, stagedAddon, isUpgrade); + + if (requiresRestart) { + this.state = AddonManager.STATE_INSTALLED; + AddonManagerPrivate.callInstallListeners("onInstallEnded", + this.listeners, this.wrapper, + this.addon.wrapper); + } + else { + // The install is completed so it should be removed from the active list + XPIProvider.removeActiveInstall(this); + + // 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._sourceBundle; + 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({ + id: this.addon.id, + source: stagedAddon, + existingAddonID + }); + + // Update the metadata in the database + this.addon._sourceBundle = file; + 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", + this.addon.wrapper); + + logger.debug("Install of " + this.sourceURI.spec + " completed."); + this.state = AddonManager.STATE_INSTALLED; + AddonManagerPrivate.callInstallListeners("onInstallEnded", + this.listeners, this.wrapper, + this.addon.wrapper); + + 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); + } + } + XPIProvider.setTelemetry(this.addon.id, "unpacked", installedUnpacked); + recordAddonTelemetry(this.addon); + } + }).bind(this)).then(null, (e) => { + logger.warn(`Failed to install ${this.file.path} from ${this.sourceURI.spec} to ${stagedAddon.path}`, e); + + if (stagedAddon.exists()) + recursiveRemove(stagedAddon); + this.state = AddonManager.STATE_INSTALL_FAILED; + this.error = AddonManager.ERROR_FILE_ACCESS; + XPIProvider.removeActiveInstall(this); + AddonManagerPrivate.callAddonListeners("onOperationCancelled", + this.addon.wrapper); + AddonManagerPrivate.callInstallListeners("onInstallFailed", + this.listeners, + this.wrapper); + }).then(() => { + this.removeTemporaryFile(); + return this.installLocation.releaseStagingDir(); + }); + } + + /** + * Stages an upgrade for next application restart. + */ + stageInstall(restartRequired, stagedAddon, isUpgrade) { + return Task.spawn((function*() { + let stagedJSON = stagedAddon.clone(); + stagedJSON.leafName = this.addon.id + ".json"; + + let installedUnpacked = 0; + + // 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 (restartRequired) { + // 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 + writeStringToFile(stagedJSON, JSON.stringify(this.addon)); + + logger.debug("Staged install of " + this.addon.id + " from " + this.sourceURI.spec + " ready; waiting for restart."); + if (isUpgrade) { + delete this.existingAddon.pendingUpgrade; + this.existingAddon.pendingUpgrade = this.addon; + } + } + + return installedUnpacked; + }).bind(this)); + } + + /** + * Removes any previously staged upgrade. + */ + unstageInstall(stagedAddon) { + return Task.spawn((function*() { + let stagedJSON = stagedAddon.clone(); + let removedAddon = stagedAddon.clone(); + + stagedJSON.append(this.addon.id + ".json"); + + if (stagedJSON.exists()) { + stagedJSON.remove(true); + } + + removedAddon.append(this.addon.id); + yield removeAsync(removedAddon); + removedAddon.leafName = this.addon.id + ".xpi"; + yield removeAsync(removedAddon); + }).bind(this)); + } + + /** + * Postone a pending update, until restart or until the add-on resumes. + * + * @param {Function} resumeFunction - a function for the add-on to run + * when resuming. + */ + postpone(resumeFunction) { + return Task.spawn((function*() { + this.state = AddonManager.STATE_POSTPONED; + + let stagingDir = this.installLocation.getStagingDir(); + let stagedAddon = stagingDir.clone(); + + yield this.installLocation.requestStagingDir(); + yield this.unstageInstall(stagedAddon); + + stagedAddon.append(this.addon.id); + stagedAddon.leafName = this.addon.id + ".xpi"; + + yield this.stageInstall(true, stagedAddon, true); + + AddonManagerPrivate.callInstallListeners("onInstallPostponed", + this.listeners, this.wrapper) + + // upgrade has been staged for restart, provide a way for it to call the + // resume function. + if (resumeFunction) { + let callback = AddonManagerPrivate.getUpgradeListener(this.addon.id); + if (callback) { + callback({ + version: this.version, + install: () => { + switch (this.state) { + case AddonManager.STATE_POSTPONED: + resumeFunction(); + break; + default: + logger.warn(`${this.addon.id} cannot resume postponed upgrade from state (${this.state})`); + break; + } + }, + }); + } + } + this.installLocation.releaseStagingDir(); + }).bind(this)); + } +} + +class LocalAddonInstall extends AddonInstall { + /** + * Initialises this install to be an install from a local file. + * + * @returns Promise + * A Promise that resolves when the object is ready to use. + */ + init() { + return Task.spawn((function*() { + 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; + XPIProvider.removeActiveInstall(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; + XPIProvider.removeActiveInstall(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; + XPIProvider.removeActiveInstall(this); + return; + } + } + + try { + yield this.loadManifest(this.file); + } catch ([error, message]) { + logger.warn("Invalid XPI", message); + this.state = AddonManager.STATE_DOWNLOAD_FAILED; + this.error = error; + XPIProvider.removeActiveInstall(this); + AddonManagerPrivate.callInstallListeners("onNewInstall", + this.listeners, + this.wrapper); + return; + } + + let addon = yield new Promise(resolve => { + XPIDatabase.getVisibleAddonForID(this.addon.id, resolve); + }); + + this.existingAddon = addon; + if (addon) + applyBlocklistChanges(addon, this.addon); + this.addon.updateDate = Date.now(); + this.addon.installDate = addon ? addon.installDate : this.addon.updateDate; + + if (!this.addon.isCompatible) { + this.state = AddonManager.STATE_CHECKING; + + yield new Promise(resolve => { + new UpdateChecker(this.addon, { + onUpdateFinished: aAddon => { + this.state = AddonManager.STATE_DOWNLOADED; + AddonManagerPrivate.callInstallListeners("onNewInstall", + this.listeners, + this.wrapper); + resolve(); + } + }, AddonManager.UPDATE_WHEN_ADDON_INSTALLED); + }); + } + else { + AddonManagerPrivate.callInstallListeners("onNewInstall", + this.listeners, + this.wrapper); + + } + }).bind(this)); + } + + install() { + if (this.state == AddonManager.STATE_DOWNLOAD_FAILED) { + // For a local install, this state means that verification of the + // file failed (e.g., the hash or signature or manifest contents + // were invalid). It doesn't make sense to retry anything in this + // case but we have callers who don't know if their AddonInstall + // object is a local file or a download so accomodate them here. + AddonManagerPrivate.callInstallListeners("onDownloadFailed", + this.listeners, this.wrapper); + return; + } + super.install(); + } +} + +class DownloadAddonInstall extends AddonInstall { + /** + * Instantiates a DownloadAddonInstall + * + * @param installLocation + * The InstallLocation the add-on will be installed into + * @param url + * The nsIURL to get the add-on from + * @param name + * An optional name for the add-on + * @param hash + * An optional hash for the add-on + * @param existingAddon + * The add-on this install will update if known + * @param browser + * The browser performing the install, used to display + * authentication prompts. + * @param type + * An optional type for the add-on + * @param icons + * Optional icons for the add-on + * @param version + * An optional version for the add-on + */ + constructor(installLocation, url, hash, existingAddon, browser, + name, type, icons, version) { + super(installLocation, url, hash, existingAddon); + + this.browser = browser; + + this.state = AddonManager.STATE_AVAILABLE; + this.name = name; + this.type = type; + this.version = version; + this.icons = icons; + + this.stream = null; + this.crypto = null; + this.badCertHandler = null; + this.restartDownload = false; + + AddonManagerPrivate.callInstallListeners("onNewInstall", this.listeners, + this.wrapper); + } + + install() { + switch (this.state) { + case AddonManager.STATE_AVAILABLE: + this.startDownload(); + 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; + this.startDownload(); + break; + default: + super.install(); + } + } + + cancel() { + if (this.state == AddonManager.STATE_DOWNLOADING) { + if (this.channel) { + logger.debug("Cancelling download of " + this.sourceURI.spec); + this.channel.cancel(Cr.NS_BINDING_ABORTED); + } + } else { + super.cancel(); + } + } + + observe(aSubject, aTopic, aData) { + // Network is going offline + this.cancel(); + } + + /** + * Starts downloading the add-on's XPI file. + */ + 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() { + 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 { + let requireBuiltIn = Preferences.get(PREF_INSTALL_REQUIREBUILTINCERTS, true); + this.badCertHandler = new CertUtils.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(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(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(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(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 { + CertUtils.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; + } + + this.loadManifest(this.file).then(() => { + if (this.addon.isCompatible) { + this.downloadCompleted(); + } + else { + // TODO Should we send some event here (bug 557716)? + this.state = AddonManager.STATE_CHECKING; + new UpdateChecker(this.addon, { + onUpdateFinished: aAddon => this.downloadCompleted(), + }, AddonManager.UPDATE_WHEN_ADDON_INSTALLED); + } + }, ([error, message]) => { + this.removeTemporaryFile(); + this.downloadFailed(error, message); + }); + } + 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(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() { + XPIDatabase.getVisibleAddonForID(this.addon.id, aAddon => { + if (aAddon) + this.existingAddon = aAddon; + + this.state = AddonManager.STATE_DOWNLOADED; + this.addon.updateDate = Date.now(); + + if (this.existingAddon) { + this.addon.existingAddonID = this.existingAddon.id; + this.addon.installDate = this.existingAddon.installDate; + applyBlocklistChanges(this.existingAddon, this.addon); + } + else { + this.addon.installDate = this.addon.updateDate; + } + + if (AddonManagerPrivate.callInstallListeners("onDownloadEnded", + this.listeners, + this.wrapper)) { + // If a listener changed our state then do not proceed with the install + if (this.state != AddonManager.STATE_DOWNLOADED) + return; + + // If an upgrade listener is registered for this add-on, pass control + // over the upgrade to the add-on. + if (AddonManagerPrivate.hasUpgradeListener(this.addon.id)) { + logger.info(`add-on ${this.addon.id} has an upgrade listener, postponing upgrade until restart`); + let resumeFn = () => { + logger.info(`${this.addon.id} has resumed a previously postponed upgrade`); + this.state = AddonManager.STATE_DOWNLOADED; + this.install(); + } + this.postpone(resumeFn); + } else { + // no upgrade listener present, so proceed with normal install + this.install(); + if (this.linkedInstalls) { + for (let install of this.linkedInstalls) { + if (install.state == AddonManager.STATE_DOWNLOADED) + install.install(); + } + } + } + } + }); + } + + getInterface(iid) { + if (iid.equals(Ci.nsIAuthPrompt2)) { + let win = null; + if (this.browser) { + win = this.browser.contentWindow || this.browser.ownerDocument.defaultView; + } + + let factory = Cc["@mozilla.org/prompter;1"]. + getService(Ci.nsIPromptFactory); + let prompt = factory.getPrompt(win, Ci.nsIAuthPrompt2); + + if (this.browser && prompt instanceof Ci.nsILoginManagerPrompter) + prompt.browser = this.browser; + + return prompt; + } + else if (iid.equals(Ci.nsIChannelEventSink)) { + return this; + } + + return this.badCertHandler.getInterface(iid); + } + + /** + * Postone a pending update, until restart or until the add-on resumes. + * + * @param {Function} resumeFn - a function for the add-on to run + * when resuming. + */ + postpone(resumeFn) { + return Task.spawn((function*() { + this.state = AddonManager.STATE_POSTPONED; + + let stagingDir = this.installLocation.getStagingDir(); + let stagedAddon = stagingDir.clone(); + + yield this.installLocation.requestStagingDir(); + yield this.unstageInstall(stagedAddon); + + stagedAddon.append(this.addon.id); + stagedAddon.leafName = this.addon.id + ".xpi"; + + yield this.stageInstall(true, stagedAddon, true); + + AddonManagerPrivate.callInstallListeners("onInstallPostponed", + this.listeners, this.wrapper) + + // upgrade has been staged for restart, provide a way for it to call the + // resume function. + let callback = AddonManagerPrivate.getUpgradeListener(this.addon.id); + if (callback) { + callback({ + version: this.version, + install: () => { + switch (this.state) { + case AddonManager.STATE_POSTPONED: + if (resumeFn) { + resumeFn(); + } + break; + default: + logger.warn(`${this.addon.id} cannot resume postponed upgrade from state (${this.state})`); + break; + } + }, + }); + } + // Release the staging directory lock, but since the staging dir is populated + // it will not be removed until resumed or installed by restart. + // See also cleanStagingDir() + this.installLocation.releaseStagingDir(); + }).bind(this)); + } +} + +/** + * This class exists just for the specific case of staged add-ons that + * fail to install at startup. When that happens, the add-on remains + * staged but we want to keep track of it like other installs so that we + * can clean it up if the same add-on is installed again (see the comment + * about "pending installs for the same add-on" in AddonInstall.startInstall) + */ +class StagedAddonInstall extends AddonInstall { + constructor(installLocation, dir, manifest) { + super(installLocation, dir); + + this.name = manifest.name; + this.type = manifest.type; + this.version = manifest.version; + this.icons = manifest.icons; + this.releaseNotesURI = manifest.releaseNotesURI ? + NetUtil.newURI(manifest.releaseNotesURI) : + null; + this.sourceURI = manifest.sourceURI ? + NetUtil.newURI(manifest.sourceURI) : + null; + this.file = null; + this.addon = manifest; + + this.state = AddonManager.STATE_INSTALLED; + } +} + +/** + * Creates a new AddonInstall to install an add-on from a local file. + * + * @param file + * The file to install + * @param location + * The location to install to + * @returns Promise + * A Promise that resolves with the new install object. + */ +function createLocalInstall(file, location) { + if (!location) { + location = XPIProvider.installLocationsByName[KEY_APP_PROFILE]; + } + let url = Services.io.newFileURI(file); + + try { + let install = new LocalAddonInstall(location, url); + return install.init().then(() => install); + } + catch (e) { + logger.error("Error creating install", e); + XPIProvider.removeActiveInstall(this); + return Promise.resolve(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 + */ +function createDownloadInstall(aCallback, aUri, aHash, aName, aIcons, + aVersion, aBrowser) { + let location = XPIProvider.installLocationsByName[KEY_APP_PROFILE]; + let url = NetUtil.newURI(aUri); + + if (url instanceof Ci.nsIFileURL) { + let install = new LocalAddonInstall(location, url, aHash); + install.init().then(() => { aCallback(install); }); + } else { + let install = new DownloadAddonInstall(location, url, aHash, null, + aBrowser, aName, null, aIcons, + aVersion); + aCallback(install); + } +} + +/** + * 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 + */ +function createUpdate(aCallback, aAddon, aUpdate) { + let url = NetUtil.newURI(aUpdate.updateURL); + + Task.spawn(function*() { + let install; + if (url instanceof Ci.nsIFileURL) { + install = new LocalAddonInstall(aAddon._installLocation, url, + aUpdate.updateHash, aAddon); + yield install.init(); + } else { + install = new DownloadAddonInstall(aAddon._installLocation, url, + aUpdate.updateHash, aAddon, null, + aAddon.selectedLocale.name, aAddon.type, + aAddon.icons, aUpdate.version); + } + try { + if (aUpdate.updateInfoURL) + install.releaseNotesURI = NetUtil.newURI(escapeAddonURI(aAddon, aUpdate.updateInfoURL)); + } + catch (e) { + // If the releaseNotesURI cannot be parsed then just ignore it. + } + + aCallback(install); + }); +} + +// This map is shared between AddonInstallWrapper and AddonWrapper +const wrapperMap = new WeakMap(); +let installFor = wrapper => wrapperMap.get(wrapper); +let addonFor = installFor; + +/** + * Creates a wrapper for an AddonInstall that only exposes the public API + * + * @param install + * The AddonInstall to create a wrapper for + */ +function AddonInstallWrapper(aInstall) { + wrapperMap.set(this, aInstall); +} + +AddonInstallWrapper.prototype = { + get __AddonInstallInternal__() { + return AppConstants.DEBUG ? installFor(this) : undefined; + }, + + get type() { + return getExternalType(installFor(this).type); + }, + + get iconURL() { + return installFor(this).icons[32]; + }, + + get existingAddon() { + let install = installFor(this); + return install.existingAddon ? install.existingAddon.wrapper : null; + }, + + get addon() { + let install = installFor(this); + return install.addon ? install.addon.wrapper : null; + }, + + get sourceURI() { + return installFor(this).sourceURI; + }, + + get linkedInstalls() { + let install = installFor(this); + if (!install.linkedInstalls) + return null; + return install.linkedInstalls.map(i => i.wrapper); + }, + + install: function() { + installFor(this).install(); + }, + + cancel: function() { + installFor(this).cancel(); + }, + + addListener: function(listener) { + installFor(this).addListener(listener); + }, + + removeListener: function(listener) { + installFor(this).removeListener(listener); + }, +}; + +["name", "version", "icons", "releaseNotesURI", "file", "state", "error", + "progress", "maxProgress", "certificate", "certName"].forEach(function(aProp) { + Object.defineProperty(AddonInstallWrapper.prototype, aProp, { + get: function() { + return installFor(this)[aProp]; + }, + enumerable: true, + }); +}); + +/** + * 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) { + if (aReason == AddonManager.UPDATE_WHEN_PERIODIC_UPDATE && + Services.prefs.getPrefType(PREF_EM_UPDATE_BACKGROUND_URL) == Services.prefs.PREF_STRING) { + updateURL = Services.prefs.getCharPref(PREF_EM_UPDATE_BACKGROUND_URL); + } else { + 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(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(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", this.addon.wrapper); + else + this.callListener("onNoCompatibilityUpdateAvailable", this.addon.wrapper); + + function sendUpdateAvailableMessages(aSelf, aInstall) { + if (aInstall) { + aSelf.callListener("onUpdateAvailable", aSelf.addon.wrapper, + aInstall.wrapper); + } + else { + aSelf.callListener("onNoUpdateAvailable", aSelf.addon.wrapper); + } + aSelf.callListener("onUpdateFinished", aSelf.addon.wrapper, + 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 + && !this.addon._installLocation.locked) { + 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; + } + + createUpdate(aInstall => { + sendUpdateAvailableMessages(this, aInstall); + }, this.addon, update); + } + else { + sendUpdateAvailableMessages(this, null); + } + }, + + /** + * Called when AddonUpdateChecker fails the update check + * + * @param aError + * An error status + */ + onUpdateCheckError: function(aError) { + XPIProvider.done(this.addon._updateCheck); + this.addon._updateCheck = null; + this.callListener("onNoCompatibilityUpdateAvailable", this.addon.wrapper); + this.callListener("onNoUpdateAvailable", this.addon.wrapper); + this.callListener("onUpdateFinished", this.addon.wrapper, aError); + }, + + /** + * Called to cancel an in-progress update check + */ + cancel: function() { + 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() { + this._hasResourceCache = new Map(); + + XPCOMUtils.defineLazyGetter(this, "wrapper", () => { + return new AddonWrapper(this); + }); +} + +AddonInternal.prototype = { + _selectedLocale: null, + _hasResourceCache: null, + active: false, + visible: false, + userDisabled: false, + appDisabled: false, + softDisabled: false, + sourceURI: null, + releaseNotesURI: null, + foreignInstall: false, + seen: true, + skinnable: false, + + /** + * @property {Array} dependencies + * An array of bootstrapped add-on IDs on which this add-on depends. + * The add-on will remain appDisabled if any of the dependent + * add-ons is not installed and enabled. + */ + dependencies: Object.freeze([]), + hasEmbeddedWebExtension: false, + + get selectedLocale() { + if (this._selectedLocale) + return this._selectedLocale; + let locale = 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 isCorrectlySigned() { + switch (this._installLocation.name) { + case KEY_APP_SYSTEM_ADDONS: + // System add-ons must be signed by the system key. + return this.signedState == AddonManager.SIGNEDSTATE_SYSTEM + + case KEY_APP_SYSTEM_DEFAULTS: + case KEY_APP_TEMPORARY: + // Temporary and built-in system add-ons do not require signing. + return true; + + case KEY_APP_SYSTEM_SHARE: + case KEY_APP_SYSTEM_LOCAL: + // On UNIX platforms except OSX, an additional location for system + // add-ons exists in /usr/{lib,share}/mozilla/extensions. Add-ons + // installed there do not require signing. + if (Services.appinfo.OS != "Darwin") + return true; + break; + } + + if (this.signedState === AddonManager.SIGNEDSTATE_NOT_REQUIRED) + return true; + return this.signedState > AddonManager.SIGNEDSTATE_MISSING; + }, + + 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(aAppVersion, aPlatformVersion) { + let app = this.matchingTargetApplication; + if (!app) + return false; + + // set reasonable defaults for minVersion and maxVersion + let minVersion = app.minVersion || "0"; + let maxVersion = app.maxVersion || "*"; + + if (!aAppVersion) + aAppVersion = Services.appinfo.version; + if (!aPlatformVersion) + aPlatformVersion = Services.appinfo.platformVersion; + + let version; + if (app.id == Services.appinfo.ID) + version = aAppVersion; + else if (app.id == TOOLKIT_ID) + 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; + if (app.id == Services.appinfo.ID) + minCompatVersion = XPIProvider.minCompatibleAppVersion; + else if (app.id == TOOLKIT_ID) + minCompatVersion = XPIProvider.minCompatiblePlatformVersion; + + if (minCompatVersion && + Services.vc.compare(minCompatVersion, maxVersion) > 0) + return false; + + return Services.vc.compare(version, minVersion) >= 0; + } + + return (Services.vc.compare(version, minVersion) >= 0) && + (Services.vc.compare(version, 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; + } + return app; + }, + + get blocklistState() { + let staticItem = findMatchingStaticBlocklistItem(this); + if (staticItem) + return staticItem.level; + + return Blocklist.getAddonBlocklistState(this.wrapper); + }, + + 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(this.wrapper); + }, + + applyCompatibilityUpdate: function(aUpdate, aSyncCompatibility) { + for (let targetApp of this.targetApplications) { + for (let updateTarget of aUpdate.targetApplications) { + if (targetApp.id == updateTarget.id && (aSyncCompatibility || + Services.vc.compare(targetApp.maxVersion, updateTarget.maxVersion) < 0)) { + targetApp.minVersion = updateTarget.minVersion; + targetApp.maxVersion = updateTarget.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(aKey) { + let obj = {}; + for (let prop in this) { + // Ignore the wrapper property + if (prop == "wrapper") + continue; + + // 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(aObj) { + for (let prop of PENDING_INSTALL_METADATA) { + if (!(prop in aObj)) + continue; + + this[prop] = aObj[prop]; + } + + // Compatibility info may have changed so update appDisabled + this.appDisabled = !isUsableAddon(this); + }, + + permissions: function() { + let permissions = 0; + + // Add-ons that aren't installed cannot be modified in any way + if (!(this.inDatabase)) + return permissions; + + 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) { + // Experiments cannot be upgraded. + // System add-on upgrades are triggered through a different mechanism (see updateSystemAddons()) + let isSystem = (this._installLocation.name == KEY_APP_SYSTEM_DEFAULTS || + this._installLocation.name == KEY_APP_SYSTEM_ADDONS); + // Add-ons that are installed by a file link cannot be upgraded. + if (this.type != "experiment" && + !this._installLocation.isLinkedAddon(this.id) && !isSystem) { + permissions |= AddonManager.PERM_CAN_UPGRADE; + } + + permissions |= AddonManager.PERM_CAN_UNINSTALL; + } + + return permissions; + }, +}; + +/** + * The AddonWrapper wraps an Addon to provide the data visible to consumers of + * the public API. + */ +function AddonWrapper(aAddon) { + wrapperMap.set(this, aAddon); +} + +AddonWrapper.prototype = { + get __AddonInternal__() { + return AppConstants.DEBUG ? addonFor(this) : undefined; + }, + + get seen() { + return addonFor(this).seen; + }, + + get hasEmbeddedWebExtension() { + return addonFor(this).hasEmbeddedWebExtension; + }, + + markAsSeen: function() { + addonFor(this).seen = true; + XPIDatabase.saveChanges(); + }, + + get type() { + return getExternalType(addonFor(this).type); + }, + + get isWebExtension() { + return addonFor(this).type == "webextension"; + }, + + get temporarilyInstalled() { + return addonFor(this)._installLocation == TemporaryInstallLocation; + }, + + get aboutURL() { + return this.isActive ? addonFor(this)["aboutURL"] : null; + }, + + get optionsURL() { + if (!this.isActive) { + return null; + } + + let addon = addonFor(this); + if (addon.optionsURL) { + if (this.isWebExtension || this.hasEmbeddedWebExtension) { + // The internal object's optionsURL property comes from the addons + // DB and should be a relative URL. However, extensions with + // options pages installed before bug 1293721 was fixed got absolute + // URLs in the addons db. This code handles both cases. + let base = ExtensionManagement.getURLForExtension(addon.id); + if (!base) { + return null; + } + return new URL(addon.optionsURL, base).href; + } + return addon.optionsURL; + } + + if (this.hasResource("options.xul")) + return this.getResourceURI("options.xul").spec; + + return null; + }, + + get optionsType() { + if (!this.isActive) + return null; + + let addon = addonFor(this); + let hasOptionsXUL = this.hasResource("options.xul"); + let hasOptionsURL = !!this.optionsURL; + + if (addon.optionsType) { + switch (parseInt(addon.optionsType, 10)) { + case AddonManager.OPTIONS_TYPE_DIALOG: + case AddonManager.OPTIONS_TYPE_TAB: + return hasOptionsURL ? addon.optionsType : null; + case AddonManager.OPTIONS_TYPE_INLINE: + case AddonManager.OPTIONS_TYPE_INLINE_INFO: + case AddonManager.OPTIONS_TYPE_INLINE_BROWSER: + return (hasOptionsXUL || hasOptionsURL) ? addon.optionsType : null; + } + return null; + } + + if (hasOptionsXUL) + return AddonManager.OPTIONS_TYPE_INLINE; + + if (hasOptionsURL) + return AddonManager.OPTIONS_TYPE_DIALOG; + + return null; + }, + + get iconURL() { + return AddonManager.getPreferredIconURL(this, 48); + }, + + get icon64URL() { + return AddonManager.getPreferredIconURL(this, 64); + }, + + get icons() { + let addon = addonFor(this); + let icons = {}; + + if (addon._repositoryAddon) { + for (let size in addon._repositoryAddon.icons) { + icons[size] = addon._repositoryAddon.icons[size]; + } + } + + if (addon.icons) { + for (let size in addon.icons) { + icons[size] = this.getResourceURI(addon.icons[size]).spec; + } + } else { + // legacy add-on that did not update its icon data yet + if (this.hasResource("icon.png")) { + icons[32] = icons[48] = this.getResourceURI("icon.png").spec; + } + if (this.hasResource("icon64.png")) { + icons[64] = this.getResourceURI("icon64.png").spec; + } + } + + if (this.isActive && addon.iconURL) { + icons[32] = addon.iconURL; + icons[48] = addon.iconURL; + } + + if (this.isActive && addon.icon64URL) { + icons[64] = addon.icon64URL; + } + + Object.freeze(icons); + return icons; + }, + + get screenshots() { + let addon = addonFor(this); + let repositoryAddon = addon._repositoryAddon; + if (repositoryAddon && ("screenshots" in repositoryAddon)) { + let repositoryScreenshots = repositoryAddon.screenshots; + if (repositoryScreenshots && repositoryScreenshots.length > 0) + return repositoryScreenshots; + } + + if (addon.type == "theme" && this.hasResource("preview.png")) { + let url = this.getResourceURI("preview.png").spec; + return [new AddonManagerPrivate.AddonScreenshot(url)]; + } + + return null; + }, + + get applyBackgroundUpdates() { + return addonFor(this).applyBackgroundUpdates; + }, + set applyBackgroundUpdates(val) { + let addon = addonFor(this); + if (this.type == "experiment") { + logger.warn("Setting applyBackgroundUpdates on an experiment is not supported."); + return addon.applyBackgroundUpdates; + } + + if (val != AddonManager.AUTOUPDATE_DEFAULT && + val != AddonManager.AUTOUPDATE_DISABLE && + val != AddonManager.AUTOUPDATE_ENABLE) { + val = val ? AddonManager.AUTOUPDATE_DEFAULT : + AddonManager.AUTOUPDATE_DISABLE; + } + + if (val == addon.applyBackgroundUpdates) + return val; + + XPIDatabase.setAddonProperties(addon, { + applyBackgroundUpdates: val + }); + AddonManagerPrivate.callAddonListeners("onPropertyChanged", this, ["applyBackgroundUpdates"]); + + return val; + }, + + set syncGUID(val) { + let addon = addonFor(this); + if (addon.syncGUID == val) + return val; + + if (addon.inDatabase) + XPIDatabase.setAddonSyncGUID(addon, val); + + addon.syncGUID = val; + + return val; + }, + + get install() { + let addon = addonFor(this); + if (!("_install" in addon) || !addon._install) + return null; + return addon._install.wrapper; + }, + + get pendingUpgrade() { + let addon = addonFor(this); + return addon.pendingUpgrade ? addon.pendingUpgrade.wrapper : null; + }, + + get scope() { + let addon = addonFor(this); + if (addon._installLocation) + return addon._installLocation.scope; + + return AddonManager.SCOPE_PROFILE; + }, + + get pendingOperations() { + let addon = addonFor(this); + let pending = 0; + if (!(addon.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 (!addon._install || addon._install.state == AddonManager.STATE_INSTALLING || + addon._install.state == AddonManager.STATE_INSTALLED) + return AddonManager.PENDING_INSTALL; + } + else if (addon.pendingUninstall) { + // If an add-on is pending uninstall then we ignore any other pending + // operations + return AddonManager.PENDING_UNINSTALL; + } + + if (addon.active && addon.disabled) + pending |= AddonManager.PENDING_DISABLE; + else if (!addon.active && !addon.disabled) + pending |= AddonManager.PENDING_ENABLE; + + if (addon.pendingUpgrade) + pending |= AddonManager.PENDING_UPGRADE; + + return pending; + }, + + get operationsRequiringRestart() { + let addon = addonFor(this); + let ops = 0; + if (XPIProvider.installRequiresRestart(addon)) + ops |= AddonManager.OP_NEEDS_RESTART_INSTALL; + if (XPIProvider.uninstallRequiresRestart(addon)) + ops |= AddonManager.OP_NEEDS_RESTART_UNINSTALL; + if (XPIProvider.enableRequiresRestart(addon)) + ops |= AddonManager.OP_NEEDS_RESTART_ENABLE; + if (XPIProvider.disableRequiresRestart(addon)) + ops |= AddonManager.OP_NEEDS_RESTART_DISABLE; + + return ops; + }, + + get isDebuggable() { + return this.isActive && addonFor(this).bootstrap; + }, + + get permissions() { + return addonFor(this).permissions(); + }, + + get isActive() { + let addon = addonFor(this); + if (!addon.active) + return false; + if (!Services.appinfo.inSafeMode) + return true; + return addon.bootstrap && canRunInSafeMode(addon); + }, + + get userDisabled() { + let addon = addonFor(this); + return addon.softDisabled || addon.userDisabled; + }, + set userDisabled(val) { + let addon = addonFor(this); + if (val == this.userDisabled) { + return val; + } + + if (addon.inDatabase) { + if (addon.type == "theme" && val) { + if (addon.internalName == XPIProvider.defaultSkin) + throw new Error("Cannot disable the default theme"); + XPIProvider.enableDefaultTheme(); + } + else { + // hidden and system add-ons should not be user disasbled, + // as there is no UI to re-enable them. + if (this.hidden) { + throw new Error(`Cannot disable hidden add-on ${addon.id}`); + } + XPIProvider.updateAddonDisabledState(addon, val); + } + } + else { + addon.userDisabled = val; + // When enabling remove the softDisabled flag + if (!val) + addon.softDisabled = false; + } + + return val; + }, + + set softDisabled(val) { + let addon = addonFor(this); + if (val == addon.softDisabled) + return val; + + if (addon.inDatabase) { + // When softDisabling a theme just enable the active theme + if (addon.type == "theme" && val && !addon.userDisabled) { + if (addon.internalName == XPIProvider.defaultSkin) + throw new Error("Cannot disable the default theme"); + XPIProvider.enableDefaultTheme(); + } + else { + XPIProvider.updateAddonDisabledState(addon, undefined, val); + } + } + else if (!addon.userDisabled) { + // Only set softDisabled if not already disabled + addon.softDisabled = val; + } + + return val; + }, + + get hidden() { + let addon = addonFor(this); + if (addon._installLocation.name == KEY_APP_TEMPORARY) + return false; + + return (addon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS || + addon._installLocation.name == KEY_APP_SYSTEM_ADDONS); + }, + + get isSystem() { + let addon = addonFor(this); + return (addon._installLocation.name == KEY_APP_SYSTEM_DEFAULTS || + addon._installLocation.name == KEY_APP_SYSTEM_ADDONS); + }, + + // Returns true if Firefox Sync should sync this addon. Only non-hotfixes + // directly in the profile are considered syncable. + get isSyncable() { + let addon = addonFor(this); + let hotfixID = Preferences.get(PREF_EM_HOTFIX_ID, undefined); + if (hotfixID && hotfixID == addon.id) { + return false; + } + return (addon._installLocation.name == KEY_APP_PROFILE); + }, + + isCompatibleWith: function(aAppVersion, aPlatformVersion) { + return addonFor(this).isCompatibleWith(aAppVersion, aPlatformVersion); + }, + + uninstall: function(alwaysAllowUndo) { + let addon = addonFor(this); + XPIProvider.uninstallAddon(addon, alwaysAllowUndo); + }, + + cancelUninstall: function() { + let addon = addonFor(this); + XPIProvider.cancelUninstallAddon(addon); + }, + + findUpdates: function(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(addonFor(this), aListener, aReason, aAppVersion, aPlatformVersion); + }, + + // Returns true if there was an update in progress, false if there was no update to cancel + cancelUpdate: function() { + let addon = addonFor(this); + if (addon._updateCheck) { + addon._updateCheck.cancel(); + return true; + } + return false; + }, + + hasResource: function(aPath) { + let addon = addonFor(this); + if (addon._hasResourceCache.has(aPath)) + return addon._hasResourceCache.get(aPath); + + let bundle = addon._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) { + addon._hasResourceCache.set(aPath, false); + return false; + } + + if (isDir) { + if (aPath) + aPath.split("/").forEach(part => bundle.append(part)); + let result = bundle.exists(); + addon._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); + addon._hasResourceCache.set(aPath, result); + return result; + } + catch (e) { + addon._hasResourceCache.set(aPath, false); + return false; + } + finally { + zipReader.close(); + } + }, + + /** + * Reloads the add-on. + * + * For temporarily installed add-ons, this uninstalls and re-installs the + * add-on. Otherwise, the addon is disabled and then re-enabled, and the cache + * is flushed. + * + * @return Promise + */ + reload: function() { + return new Promise((resolve) => { + const addon = addonFor(this); + + logger.debug(`reloading add-on ${addon.id}`); + + if (!this.temporarilyInstalled) { + let addonFile = addon.getResourceURI; + XPIProvider.updateAddonDisabledState(addon, true); + Services.obs.notifyObservers(addonFile, "flush-cache-entry", null); + XPIProvider.updateAddonDisabledState(addon, false) + resolve(); + } else { + // This function supports re-installing an existing add-on. + resolve(AddonManager.installTemporaryAddon(addon._sourceBundle)); + } + }); + }, + + /** + * 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 + */ + getResourceURI: function(aPath) { + let addon = addonFor(this); + if (!aPath) + return NetUtil.newURI(addon._sourceBundle); + + return getURIForResourceInFile(addon._sourceBundle, aPath); + } +}; + +/** + * The PrivateWrapper is used to expose certain functionality only when being + * called with the add-on instanceID, disallowing other add-ons to access it. + */ +function PrivateWrapper(aAddon) { + AddonWrapper.call(this, aAddon); +} + +PrivateWrapper.prototype = Object.create(AddonWrapper.prototype); +Object.assign(PrivateWrapper.prototype, { + addonId() { + return this.id; + }, + + /** + * Retrieves the preferred global context to be used from the + * add-on debugging window. + * + * @returns global + * The object set as global context. Must be a window object. + */ + getDebugGlobal(global) { + let activeAddon = XPIProvider.activeAddons.get(this.id); + if (activeAddon) { + return activeAddon.debugGlobal; + } + + return null; + }, + + /** + * Defines a global context to be used in the console + * of the add-on debugging window. + * + * @param global + * The object to set as global context. Must be a window object. + */ + setDebugGlobal(global) { + if (!global) { + // If the new global is null, notify the listeners regardless + // from the current state of the addon. + // NOTE: this happen after the addon has been disabled and + // the global will never be set to null otherwise. + AddonManagerPrivate.callAddonListeners("onPropertyChanged", + addonFor(this), + ["debugGlobal"]); + } else { + let activeAddon = XPIProvider.activeAddons.get(this.id); + if (activeAddon) { + let globalChanged = activeAddon.debugGlobal != global; + activeAddon.debugGlobal = global; + + if (globalChanged) { + AddonManagerPrivate.callAddonListeners("onPropertyChanged", + addonFor(this), + ["debugGlobal"]); + } + } + } + } +}); + +function chooseValue(aAddon, 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]; +} + +function defineAddonWrapperProperty(name, getter) { + Object.defineProperty(AddonWrapper.prototype, name, { + get: getter, + enumerable: true, + }); +} + +["id", "syncGUID", "version", "isCompatible", "isPlatformCompatible", + "providesUpdatesSecurely", "blocklistState", "blocklistURL", "appDisabled", + "softDisabled", "skinnable", "size", "foreignInstall", "hasBinaryComponents", + "strictCompatibility", "compatibilityOverrides", "updateURL", "dependencies", + "getDataDirectory", "multiprocessCompatible", "signedState", "mpcOptedOut", + "isCorrectlySigned"].forEach(function(aProp) { + defineAddonWrapperProperty(aProp, function() { + let addon = addonFor(this); + return (aProp in addon) ? addon[aProp] : undefined; + }); +}); + +["fullDescription", "developerComments", "eula", "supportURL", + "contributionURL", "contributionAmount", "averageRating", "reviewCount", + "reviewURL", "totalDownloads", "weeklyDownloads", "dailyUsers", + "repositoryStatus"].forEach(function(aProp) { + defineAddonWrapperProperty(aProp, function() { + let addon = addonFor(this); + if (addon._repositoryAddon) + return addon._repositoryAddon[aProp]; + + return null; + }); +}); + +["installDate", "updateDate"].forEach(function(aProp) { + defineAddonWrapperProperty(aProp, function() { + return new Date(addonFor(this)[aProp]); + }); +}); + +["sourceURI", "releaseNotesURI"].forEach(function(aProp) { + defineAddonWrapperProperty(aProp, function() { + let addon = addonFor(this); + + // Temporary Installed Addons do not have a "sourceURI", + // But we can use the "_sourceBundle" as an alternative, + // which points to the path of the addon xpi installed + // or its source dir (if it has been installed from a + // directory). + if (aProp == "sourceURI" && this.temporarilyInstalled) { + return Services.io.newFileURI(addon._sourceBundle); + } + + let [target, fromRepo] = chooseValue(addon, addon, aProp); + if (!target) + return null; + if (fromRepo) + return target; + return NetUtil.newURI(target); + }); +}); + +PROP_LOCALE_SINGLE.forEach(function(aProp) { + defineAddonWrapperProperty(aProp, function() { + let addon = addonFor(this); + // Override XPI creator if repository creator is defined + if (aProp == "creator" && + addon._repositoryAddon && addon._repositoryAddon.creator) { + return addon._repositoryAddon.creator; + } + + let result = null; + + if (addon.active) { + try { + let pref = PREF_EM_EXTENSION_FORMAT + addon.id + "." + aProp; + let value = Preferences.get(pref, null, Ci.nsIPrefLocalizedString); + if (value) + result = value; + } + catch (e) { + } + } + + let rest; + if (result == null) + [result, ...rest] = chooseValue(addon, addon.selectedLocale, aProp); + + if (aProp == "creator") + return result ? new AddonManagerPrivate.AddonAuthor(result) : null; + + return result; + }); +}); + +PROP_LOCALE_MULTI.forEach(function(aProp) { + defineAddonWrapperProperty(aProp, function() { + let addon = addonFor(this); + let results = null; + let usedRepository = false; + + if (addon.active) { + let pref = PREF_EM_EXTENSION_FORMAT + addon.id + "." + + aProp.substring(0, aProp.length - 1); + let list = Services.prefs.getChildList(pref, {}); + if (list.length > 0) { + list.sort(); + results = []; + for (let childPref of list) { + let value = Preferences.get(childPref, null, Ci.nsIPrefLocalizedString); + if (value) + results.push(value); + } + } + } + + if (results == null) + [results, usedRepository] = chooseValue(addon, addon.selectedLocale, aProp); + + if (results && !usedRepository) { + results = results.map(function(aResult) { + return new AddonManagerPrivate.AddonAuthor(aResult); + }); + } + + return results; + }); +}); + +/** + * 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. + * + * @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 + */ +function DirectoryInstallLocation(aName, aDirectory, aScope) { + this._name = aName; + this.locked = true; + this._directory = aDirectory; + this._scope = aScope + this._IDToFileMap = {}; + this._linkedAddons = []; + + if (!aDirectory || !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 + + /** + * 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(aFile) { + let linkedDirectory; + if (aFile.isSymlink()) { + linkedDirectory = aFile.clone(); + try { + linkedDirectory.normalize(); + } catch (e) { + logger.warn("Symbolic link " + aFile.path + " points to a path" + + " which does not exist"); + return null; + } + } + else { + 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) { + 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) { + 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() { + // 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_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 (!directLoad && (entry.isFile() || entry.isSymlink())) { + 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; + 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. + */ + getAddonLocations: function() { + let locations = new Map(); + for (let id in this._IDToFileMap) { + locations.set(id, this._IDToFileMap[id].clone()); + } + return locations; + }, + + /** + * 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(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(aId) { + return this._linkedAddons.indexOf(aId) != -1; + } +}; + +/** + * An extension of DirectoryInstallLocation which adds methods to installing + * and removing add-ons from the directory at runtime. + * + * @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 + */ +function MutableDirectoryInstallLocation(aName, aDirectory, aScope) { + DirectoryInstallLocation.call(this, aName, aDirectory, aScope); + this.locked = false; + this._stagingDirLock = 0; +} + +MutableDirectoryInstallLocation.prototype = Object.create(DirectoryInstallLocation.prototype); +Object.assign(MutableDirectoryInstallLocation.prototype, { + /** + * Gets the staging directory to put add-ons that are pending install and + * uninstall into. + * + * @return an nsIFile + */ + getStagingDir: function() { + 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 + } + }, + + /** + * 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() { + 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 id + * The ID of the add-on to install + * @param source + * The source nsIFile to install from + * @param existingAddonID + * The ID of an existing add-on to uninstall at the same time + * @param action + * What to we do with the given source file: + * "move" + * Default action, the source files will be moved to the new + * location, + * "copy" + * The source files will be copied, + * "proxy" + * A "proxy file" is going to refer to the source file path + * @return an nsIFile indicating where the add-on was installed to + */ + installAddon: function({ id, source, existingAddonID, action = "move" }) { + let trashDir = this.getTrashDir(); + + let transaction = new SafeInstallOperation(); + + let moveOldAddon = aId => { + let file = this._directory.clone(); + file.append(aId); + + if (file.exists()) + transaction.moveUnder(file, trashDir); + + file = this._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(id); + if (existingAddonID && existingAddonID != id) { + moveOldAddon(existingAddonID); + + { + // 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", existingAddonID], false, true + ); + + if (oldDataDir.exists()) { + let newDataDir = FileUtils.getDir( + KEY_PROFILEDIR, ["extension-data", id], false, true + ); + if (newDataDir.exists()) { + let trashData = trashDir.clone(); + trashData.append("data-directory"); + transaction.moveUnder(newDataDir, trashData); + } + + transaction.moveTo(oldDataDir, newDataDir); + } + } + } + + if (action == "copy") { + transaction.copy(source, this._directory); + } + else if (action == "move") { + if (source.isFile()) + flushJarCache(source); + + transaction.moveUnder(source, this._directory); + } + // Do nothing for the proxy file as we sideload an addon permanently + } + 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 " + id, e); + } + } + + let newFile = this._directory.clone(); + + if (action == "proxy") { + // When permanently installing sideloaded addon, we just put a proxy file + // refering to the addon sources + newFile.append(id); + + writeStringToFile(newFile, source.path); + } else { + newFile.append(source.leafName); + } + + try { + newFile.lastModifiedTime = Date.now(); + } catch (e) { + logger.warn("failed to set lastModifiedTime on " + newFile.path, e); + } + this._IDToFileMap[id] = newFile; + XPIProvider._addURIMapping(id, newFile); + + if (existingAddonID && existingAddonID != id && + existingAddonID in this._IDToFileMap) { + delete this._IDToFileMap[existingAddonID]; + } + + 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(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._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._IDToFileMap[aId]; + }, +}); + +/** + * An object which identifies a directory install location for system add-ons + * upgrades. + * + * The location consists of a directory which contains the add-ons installed. + * + * @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 aResetSet + * True to throw away the current add-on set + */ +function SystemAddonInstallLocation(aName, aDirectory, aScope, aResetSet) { + this._baseDir = aDirectory; + this._nextDir = null; + + this._stagingDirLock = 0; + + if (aResetSet) + this.resetAddonSet(); + + this._addonSet = this._loadAddonSet(); + + this._directory = null; + if (this._addonSet.directory) { + this._directory = aDirectory.clone(); + this._directory.append(this._addonSet.directory); + logger.info("SystemAddonInstallLocation scanning directory " + this._directory.path); + } + else { + logger.info("SystemAddonInstallLocation directory is missing"); + } + + DirectoryInstallLocation.call(this, aName, this._directory, aScope); + this.locked = false; +} + +SystemAddonInstallLocation.prototype = Object.create(DirectoryInstallLocation.prototype); +Object.assign(SystemAddonInstallLocation.prototype, { + /** + * 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 staging directory to put add-ons that are pending install and + * uninstall into. + * + * @return {nsIFile} - staging directory for system add-on upgrades. + */ + getStagingDir: function() { + this._addonSet = this._loadAddonSet(); + let dir = null; + if (this._addonSet.directory) { + this._directory = this._baseDir.clone(); + this._directory.append(this._addonSet.directory); + dir = this._directory.clone(); + dir.append(DIR_STAGE); + } + else { + logger.info("SystemAddonInstallLocation directory is missing"); + } + + return dir; + }, + + requestStagingDir: function() { + this._stagingDirLock++; + if (this._stagingDirPromise) + return this._stagingDirPromise; + + this._addonSet = this._loadAddonSet(); + if (this._addonSet.directory) { + this._directory = this._baseDir.clone(); + this._directory.append(this._addonSet.directory); + } + + 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(); + }, + + /** + * Reads the current set of system add-ons + */ + _loadAddonSet: function() { + try { + let setStr = Preferences.get(PREF_SYSTEM_ADDON_SET, null); + if (setStr) { + let addonSet = JSON.parse(setStr); + if ((typeof addonSet == "object") && addonSet.schema == 1) + return addonSet; + } + } + catch (e) { + logger.error("Malformed system add-on set, resetting."); + } + + return { schema: 1, addons: {} }; + }, + + /** + * Saves the current set of system add-ons + * + * @param {Object} aAddonSet - object containing schema, directory and set + * of system add-on IDs and versions. + */ + _saveAddonSet: function(aAddonSet) { + Preferences.set(PREF_SYSTEM_ADDON_SET, JSON.stringify(aAddonSet)); + }, + + getAddonLocations: function() { + // Updated system add-ons are ignored in safe mode + if (Services.appinfo.inSafeMode) + return new Map(); + + let addons = DirectoryInstallLocation.prototype.getAddonLocations.call(this); + + // Strip out any unexpected add-ons from the list + for (let id of addons.keys()) { + if (!(id in this._addonSet.addons)) + addons.delete(id); + } + + return addons; + }, + + /** + * Tests whether updated system add-ons are expected. + */ + isActive: function() { + return this._directory != null; + }, + + isValidAddon: function(aAddon) { + if (aAddon.appDisabled) { + logger.warn(`System add-on ${aAddon.id} isn't compatible with the application.`); + return false; + } + + if (aAddon.unpack) { + logger.warn(`System add-on ${aAddon.id} isn't a packed add-on.`); + return false; + } + + if (!aAddon.bootstrap) { + logger.warn(`System add-on ${aAddon.id} isn't restartless.`); + return false; + } + + if (!aAddon.multiprocessCompatible) { + logger.warn(`System add-on ${aAddon.id} isn't multiprocess compatible.`); + return false; + } + + return true; + }, + + /** + * Tests whether the loaded add-on information matches what is expected. + */ + isValid: function(aAddons) { + for (let id of Object.keys(this._addonSet.addons)) { + if (!aAddons.has(id)) { + logger.warn(`Expected add-on ${id} is missing from the system add-on location.`); + return false; + } + + let addon = aAddons.get(id); + if (addon.version != this._addonSet.addons[id].version) { + logger.warn(`Expected system add-on ${id} to be version ${this._addonSet.addons[id].version} but was ${addon.version}.`); + return false; + } + + if (!this.isValidAddon(addon)) + return false; + } + + return true; + }, + + /** + * Resets the add-on set so on the next startup the default set will be used. + */ + resetAddonSet: function() { + + if (this._addonSet) { + logger.info("Removing all system add-on upgrades."); + + // remove everything from the pref first, if uninstall + // fails then at least they will not be re-activated on + // next restart. + this._saveAddonSet({ schema: 1, addons: {} }); + + for (let id of Object.keys(this._addonSet.addons)) { + AddonManager.getAddonByID(id, addon => { + if (addon) { + addon.uninstall(); + } + }); + } + } + }, + + /** + * Removes any directories not currently in use or pending use after a + * restart. Any errors that happen here don't really matter as we'll attempt + * to cleanup again next time. + */ + cleanDirectories: Task.async(function*() { + + // System add-ons directory does not exist + if (!(yield OS.File.exists(this._baseDir.path))) { + return; + } + + let iterator; + try { + iterator = new OS.File.DirectoryIterator(this._baseDir.path); + } + catch (e) { + logger.error("Failed to clean updated system add-ons directories.", e); + return; + } + + try { + let entries = []; + + yield iterator.forEach(entry => { + // Skip the directory currently in use + if (this._directory && this._directory.path == entry.path) + return; + + // Skip the next directory + if (this._nextDir && this._nextDir.path == entry.path) + return; + + entries.push(entry); + }); + + for (let entry of entries) { + if (entry.isDir) { + yield OS.File.removeDir(entry.path, { + ignoreAbsent: true, + ignorePermissions: true, + }); + } + else { + yield OS.File.remove(entry.path, { + ignoreAbsent: true, + }); + } + } + } + catch (e) { + logger.error("Failed to clean updated system add-ons directories.", e); + } + finally { + iterator.close(); + } + }), + + /** + * Installs a new set of system add-ons into the location and updates the + * add-on set in prefs. + * + * @param {Array} aAddons - An array of addons to install. + */ + installAddonSet: Task.async(function*(aAddons) { + // Make sure the base dir exists + yield OS.File.makeDir(this._baseDir.path, { ignoreExisting: true }); + + let addonSet = this._loadAddonSet(); + + // Remove any add-ons that are no longer part of the set. + for (let addonID of Object.keys(addonSet.addons)) { + if (!aAddons.includes(addonID)) { + AddonManager.getAddonByID(addonID, a => a.uninstall()); + } + } + + let newDir = this._baseDir.clone(); + + let uuidGen = Cc["@mozilla.org/uuid-generator;1"]. + getService(Ci.nsIUUIDGenerator); + newDir.append("blank"); + + while (true) { + newDir.leafName = uuidGen.generateUUID().toString(); + + try { + yield OS.File.makeDir(newDir.path, { ignoreExisting: false }); + break; + } + catch (e) { + logger.debug("Could not create new system add-on updates dir, retrying", e); + } + } + + // Record the new upgrade directory. + let state = { schema: 1, directory: newDir.leafName, addons: {} }; + this._saveAddonSet(state); + + this._nextDir = newDir; + let location = this; + + let installs = []; + for (let addon of aAddons) { + let install = yield createLocalInstall(addon._sourceBundle, location); + installs.push(install); + } + + let installAddon = Task.async(function*(install) { + // Make the new install own its temporary file. + install.ownsTempFile = true; + install.install(); + }); + + let postponeAddon = Task.async(function*(install) { + let resumeFn; + if (AddonManagerPrivate.hasUpgradeListener(install.addon.id)) { + logger.info(`system add-on ${install.addon.id} has an upgrade listener, postponing upgrade set until restart`); + resumeFn = () => { + logger.info(`${install.addon.id} has resumed a previously postponed addon set`); + install.installLocation.resumeAddonSet(installs); + } + } + yield install.postpone(resumeFn); + }); + + let previousState; + + try { + // All add-ons in position, create the new state and store it in prefs + state = { schema: 1, directory: newDir.leafName, addons: {} }; + for (let addon of aAddons) { + state.addons[addon.id] = { + version: addon.version + } + } + + previousState = this._loadAddonSet(); + this._saveAddonSet(state); + + let blockers = aAddons.filter( + addon => AddonManagerPrivate.hasUpgradeListener(addon.id) + ); + + if (blockers.length > 0) { + yield waitForAllPromises(installs.map(postponeAddon)); + } else { + yield waitForAllPromises(installs.map(installAddon)); + } + } + catch (e) { + // Roll back to previous upgrade set (if present) on restart. + if (previousState) { + this._saveAddonSet(previousState); + } + // Otherwise, roll back to built-in set on restart. + // TODO try to do these restartlessly + this.resetAddonSet(); + + try { + yield OS.File.removeDir(newDir.path, { ignorePermissions: true }); + } + catch (e) { + logger.warn(`Failed to remove failed system add-on directory ${newDir.path}.`, e); + } + throw e; + } + }), + + /** + * Resumes upgrade of a previously-delayed add-on set. + */ + resumeAddonSet: Task.async(function*(installs) { + let resumeAddon = Task.async(function*(install) { + install.state = AddonManager.STATE_DOWNLOADED; + install.installLocation.releaseStagingDir(); + install.install(); + }); + + let addonSet = this._loadAddonSet(); + let addonIDs = Object.keys(addonSet.addons); + + let blockers = installs.filter( + install => AddonManagerPrivate.hasUpgradeListener(install.addon.id) + ); + + if (blockers.length > 1) { + logger.warn("Attempted to resume system add-on install but upgrade blockers are still present"); + } else { + yield waitForAllPromises(installs.map(resumeAddon)); + } + }), + + /** + * 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() { + 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 id + * The ID of the add-on to install + * @param source + * The source nsIFile to install from + * @return an nsIFile indicating where the add-on was installed to + */ + installAddon: function({id, source}) { + let trashDir = this.getTrashDir(); + let transaction = new SafeInstallOperation(); + + // If any of these operations fails the finally block will clean up the + // temporary directory + try { + if (source.isFile()) { + flushJarCache(source); + } + + transaction.moveUnder(source, 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 " + id, e); + } + } + + let newFile = this._directory.clone(); + newFile.append(source.leafName); + + try { + newFile.lastModifiedTime = Date.now(); + } catch (e) { + logger.warn("failed to set lastModifiedTime on " + newFile.path, e); + } + this._IDToFileMap[id] = newFile; + XPIProvider._addURIMapping(id, newFile); + + return newFile; + }, + + // old system add-on upgrade dirs get automatically removed + uninstallAddon: (aAddon) => {}, +}); + +/** + * An object which identifies an install location for temporary add-ons. + */ +const TemporaryInstallLocation = { + locked: false, + name: KEY_APP_TEMPORARY, + scope: AddonManager.SCOPE_TEMPORARY, + getAddonLocations: () => [], + isLinkedAddon: () => false, + installAddon: () => {}, + uninstallAddon: (aAddon) => {}, + getStagingDir: () => {}, +} + +/** + * 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 = {}; + + 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 + + /** + * Retrieves the path of this Application's data key in the registry. + */ + get _appKeyPath() { + let appVendor = Services.appinfo.vendor; + let appName = Services.appinfo.name; + + // XXX Thunderbird doesn't specify a vendor string + if (AppConstants.MOZ_APP_NAME == "thunderbird" && appVendor == "") + appVendor = "Mozilla"; + + // 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(aKey) { + let count = aKey.valueCount; + for (let i = 0; i < count; ++i) { + let id = aKey.getValueName(i); + + let file = new nsIFile(aKey.readStringValue(id)); + + if (!file.exists()) { + logger.warn("Ignoring missing add-on in " + file.path); + continue; + } + + this._IDToFileMap[id] = file; + 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. + */ + getAddonLocations: function() { + let locations = new Map(); + for (let id in this._IDToFileMap) { + locations.set(id, this._IDToFileMap[id].clone()); + } + return locations; + }, + + /** + * @see DirectoryInstallLocation + */ + isLinkedAddon: function(aId) { + return true; + } +}; + +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); diff --git a/toolkit/mozapps/extensions/internal/XPIProviderUtils.js b/toolkit/mozapps/extensions/internal/XPIProviderUtils.js new file mode 100644 index 0000000000..d04eb207c6 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/XPIProviderUtils.js @@ -0,0 +1,2255 @@ +/* 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"; + +// These are injected from XPIProvider.jsm +/* globals ADDON_SIGNING, SIGNED_TYPES, BOOTSTRAP_REASONS, DB_SCHEMA, + AddonInternal, XPIProvider, XPIStates, syncLoadManifestFromFile, + isUsableAddon, recordAddonTelemetry, applyBlocklistChanges, + flushChromeCaches, canRunInSafeMode*/ + +var Cc = Components.classes; +var Ci = Components.interfaces; +var Cr = Components.results; +var Cu = Components.utils; + +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/AddonManager.jsm"); +/* globals AddonManagerPrivate*/ +Cu.import("resource://gre/modules/Preferences.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "AddonRepository", + "resource://gre/modules/addons/AddonRepository.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "FileUtils", + "resource://gre/modules/FileUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "DeferredSave", + "resource://gre/modules/DeferredSave.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Promise", + "resource://gre/modules/Promise.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "OS", + "resource://gre/modules/osfile.jsm"); +XPCOMUtils.defineLazyServiceGetter(this, "Blocklist", + "@mozilla.org/extensions/blocklist;1", + Ci.nsIBlocklistService); + +Cu.import("resource://gre/modules/Log.jsm"); +const LOGGER_ID = "addons.xpi-utils"; + +const nsIFile = Components.Constructor("@mozilla.org/file/local;1", "nsIFile"); + +// Create a new logger for use by the Addons XPI Provider Utils +// (Requires AddonManager.jsm) +var logger = Log.repository.getLogger(LOGGER_ID); + +const KEY_PROFILEDIR = "ProfD"; +const FILE_DATABASE = "extensions.sqlite"; +const FILE_JSON_DB = "extensions.json"; +const FILE_OLD_DATABASE = "extensions.rdf"; +const FILE_XPI_ADDONS_LIST = "extensions.ini"; + +// The last version of DB_SCHEMA implemented in SQLITE +const LAST_SQLITE_DB_SCHEMA = 14; +const PREF_DB_SCHEMA = "extensions.databaseSchema"; +const PREF_PENDING_OPERATIONS = "extensions.pendingOperations"; +const PREF_EM_ENABLED_ADDONS = "extensions.enabledAddons"; +const PREF_EM_DSS_ENABLED = "extensions.dss.enabled"; +const PREF_EM_AUTO_DISABLED_SCOPES = "extensions.autoDisableScopes"; +const PREF_E10S_BLOCKED_BY_ADDONS = "extensions.e10sBlockedByAddons"; +const PREF_E10S_HAS_NONEXEMPT_ADDON = "extensions.e10s.rollout.hasAddon"; + +const KEY_APP_PROFILE = "app-profile"; +const KEY_APP_SYSTEM_ADDONS = "app-system-addons"; +const KEY_APP_SYSTEM_DEFAULTS = "app-system-defaults"; +const KEY_APP_GLOBAL = "app-global"; + +// Properties that only exist in the database +const DB_METADATA = ["syncGUID", + "installDate", + "updateDate", + "size", + "sourceURI", + "releaseNotesURI", + "applyBackgroundUpdates"]; +const DB_BOOL_METADATA = ["visible", "active", "userDisabled", "appDisabled", + "pendingUninstall", "bootstrap", "skinnable", + "softDisabled", "isForeignInstall", + "hasBinaryComponents", "strictCompatibility"]; + +// Properties to save in JSON file +const PROP_JSON_FIELDS = ["id", "syncGUID", "location", "version", "type", + "internalName", "updateURL", "updateKey", "optionsURL", + "optionsType", "aboutURL", "icons", "iconURL", "icon64URL", + "defaultLocale", "visible", "active", "userDisabled", + "appDisabled", "pendingUninstall", "descriptor", "installDate", + "updateDate", "applyBackgroundUpdates", "bootstrap", + "skinnable", "size", "sourceURI", "releaseNotesURI", + "softDisabled", "foreignInstall", "hasBinaryComponents", + "strictCompatibility", "locales", "targetApplications", + "targetPlatforms", "multiprocessCompatible", "signedState", + "seen", "dependencies", "hasEmbeddedWebExtension", "mpcOptedOut"]; + +// 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"]; + +// Time to wait before async save of XPI JSON database, in milliseconds +const ASYNC_SAVE_DELAY_MS = 20; + +const PREFIX_ITEM_URI = "urn:mozilla:item:"; +const RDFURI_ITEM_ROOT = "urn:mozilla:item:root" +const PREFIX_NS_EM = "http://www.mozilla.org/2004/em-rdf#"; + +XPCOMUtils.defineLazyServiceGetter(this, "gRDF", "@mozilla.org/rdf/rdf-service;1", + Ci.nsIRDFService); + +function EM_R(aProperty) { + return gRDF.GetResource(PREFIX_NS_EM + aProperty); +} + +/** + * 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)); +} + +/** + * Asynchronously fill in the _repositoryAddon field for one addon + */ +function getRepositoryAddon(aAddon, aCallback) { + if (!aAddon) { + aCallback(aAddon); + return; + } + function completeAddon(aRepositoryAddon) { + aAddon._repositoryAddon = aRepositoryAddon; + aAddon.compatibilityOverrides = aRepositoryAddon ? + aRepositoryAddon.compatibilityOverrides : + null; + aCallback(aAddon); + } + AddonRepository.getCachedAddonByID(aAddon.id, completeAddon); +} + +/** + * Wrap an API-supplied function in an exception handler to make it safe to call + */ +function makeSafe(aCallback) { + return function(...aArgs) { + try { + aCallback(...aArgs); + } + catch (ex) { + logger.warn("XPI Database callback failed", ex); + } + } +} + +/** + * A helper method to asynchronously call a function on an array + * of objects, calling a callback when function(x) has been gathered + * for every element of the array. + * WARNING: not currently error-safe; if the async function does not call + * our internal callback for any of the array elements, asyncMap will not + * call the callback parameter. + * + * @param aObjects + * The array of objects to process asynchronously + * @param aMethod + * Function with signature function(object, function(f_of_object)) + * @param aCallback + * Function with signature f([aMethod(object)]), called when all values + * are available + */ +function asyncMap(aObjects, aMethod, aCallback) { + var resultsPending = aObjects.length; + var results = [] + if (resultsPending == 0) { + aCallback(results); + return; + } + + function asyncMap_gotValue(aIndex, aValue) { + results[aIndex] = aValue; + if (--resultsPending == 0) { + aCallback(results); + } + } + + aObjects.map(function(aObject, aIndex, aArray) { + try { + aMethod(aObject, function(aResult) { + asyncMap_gotValue(aIndex, aResult); + }); + } + catch (e) { + logger.warn("Async map function failed", e); + asyncMap_gotValue(aIndex, undefined); + } + }); +} + +/** + * A generator to synchronously return result rows from an mozIStorageStatement. + * + * @param aStatement + * The statement to execute + */ +function* resultRows(aStatement) { + try { + while (stepStatement(aStatement)) + yield aStatement.row; + } + finally { + aStatement.reset(); + } +} + +/** + * A helper function to log an SQL error. + * + * @param aError + * The storage error code associated with the error + * @param aErrorString + * An error message + */ +function logSQLError(aError, aErrorString) { + logger.error("SQL error " + aError + ": " + aErrorString); +} + +/** + * A helper function to log any errors that occur during async statements. + * + * @param aError + * A mozIStorageError to log + */ +function asyncErrorLogger(aError) { + logSQLError(aError.result, aError.message); +} + +/** + * A helper function to step a statement synchronously and log any error that + * occurs. + * + * @param aStatement + * A mozIStorageStatement to execute + */ +function stepStatement(aStatement) { + try { + return aStatement.executeStep(); + } + catch (e) { + logSQLError(XPIDatabase.connection.lastError, + XPIDatabase.connection.lastErrorString); + throw e; + } +} + +/** + * Copies properties from one object to another. If no target object is passed + * a new object will be created and returned. + * + * @param aObject + * An object to copy from + * @param aProperties + * An array of properties to be copied + * @param aTarget + * An optional target object to copy the properties to + * @return the object that the properties were copied onto + */ +function copyProperties(aObject, aProperties, aTarget) { + if (!aTarget) + aTarget = {}; + aProperties.forEach(function(aProp) { + if (aProp in aObject) + aTarget[aProp] = aObject[aProp]; + }); + return aTarget; +} + +/** + * Copies properties from a mozIStorageRow to an object. If no target object is + * passed a new object will be created and returned. + * + * @param aRow + * A mozIStorageRow to copy from + * @param aProperties + * An array of properties to be copied + * @param aTarget + * An optional target object to copy the properties to + * @return the object that the properties were copied onto + */ +function copyRowProperties(aRow, aProperties, aTarget) { + if (!aTarget) + aTarget = {}; + aProperties.forEach(function(aProp) { + aTarget[aProp] = aRow.getResultByName(aProp); + }); + return aTarget; +} + +/** + * The DBAddonInternal is a special AddonInternal that has been retrieved from + * the database. The constructor will initialize the DBAddonInternal with a set + * of fields, which could come from either the JSON store or as an + * XPIProvider.AddonInternal created from an addon's manifest + * @constructor + * @param aLoaded + * Addon data fields loaded from JSON or the addon manifest. + */ +function DBAddonInternal(aLoaded) { + AddonInternal.call(this); + + copyProperties(aLoaded, PROP_JSON_FIELDS, this); + + if (!this.dependencies) + this.dependencies = []; + Object.freeze(this.dependencies); + + if (aLoaded._installLocation) { + this._installLocation = aLoaded._installLocation; + this.location = aLoaded._installLocation.name; + } + else if (aLoaded.location) { + this._installLocation = XPIProvider.installLocationsByName[this.location]; + } + + this._key = this.location + ":" + this.id; + + if (!aLoaded._sourceBundle) { + throw new Error("Expected passed argument to contain a descriptor"); + } + + this._sourceBundle = aLoaded._sourceBundle; + + XPCOMUtils.defineLazyGetter(this, "pendingUpgrade", function() { + for (let install of XPIProvider.installs) { + if (install.state == AddonManager.STATE_INSTALLED && + !(install.addon.inDatabase) && + install.addon.id == this.id && + install.installLocation == this._installLocation) { + delete this.pendingUpgrade; + return this.pendingUpgrade = install.addon; + } + } + return null; + }); +} + +DBAddonInternal.prototype = Object.create(AddonInternal.prototype); +Object.assign(DBAddonInternal.prototype, { + applyCompatibilityUpdate: function(aUpdate, aSyncCompatibility) { + let wasCompatible = this.isCompatible; + + 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; + XPIDatabase.saveChanges(); + } + }); + }); + if (aUpdate.multiprocessCompatible !== undefined && + aUpdate.multiprocessCompatible != this.multiprocessCompatible) { + this.multiprocessCompatible = aUpdate.multiprocessCompatible; + XPIDatabase.saveChanges(); + } + + if (wasCompatible != this.isCompatible) + XPIProvider.updateAddonDisabledState(this); + }, + + toJSON: function() { + let jsonData = copyProperties(this, PROP_JSON_FIELDS); + + // Experiments are serialized as disabled so they aren't run on the next + // startup. + if (this.type == "experiment") { + jsonData.userDisabled = true; + jsonData.active = false; + } + + return jsonData; + }, + + get inDatabase() { + return true; + } +}); + +/** + * Internal interface: find an addon from an already loaded addonDB + */ +function _findAddon(addonDB, aFilter) { + for (let addon of addonDB.values()) { + if (aFilter(addon)) { + return addon; + } + } + return null; +} + +/** + * Internal interface to get a filtered list of addons from a loaded addonDB + */ +function _filterDB(addonDB, aFilter) { + return Array.from(addonDB.values()).filter(aFilter); +} + +this.XPIDatabase = { + // true if the database connection has been opened + initialized: false, + // The database file + jsonFile: FileUtils.getFile(KEY_PROFILEDIR, [FILE_JSON_DB], true), + // Migration data loaded from an old version of the database. + migrateData: null, + // Active add-on directories loaded from extensions.ini and prefs at startup. + activeBundles: null, + + // Saved error object if we fail to read an existing database + _loadError: null, + + // Error reported by our most recent attempt to read or write the database, if any + get lastError() { + if (this._loadError) + return this._loadError; + if (this._deferredSave) + return this._deferredSave.lastError; + return null; + }, + + /** + * Mark the current stored data dirty, and schedule a flush to disk + */ + saveChanges: function() { + if (!this.initialized) { + throw new Error("Attempt to use XPI database when it is not initialized"); + } + + if (XPIProvider._closing) { + // use an Error here so we get a stack trace. + let err = new Error("XPI database modified after shutdown began"); + logger.warn(err); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_late_stack", Log.stackTrace(err)); + } + + if (!this._deferredSave) { + this._deferredSave = new DeferredSave(this.jsonFile.path, + () => JSON.stringify(this), + ASYNC_SAVE_DELAY_MS); + } + + this.updateAddonsBlockingE10s(); + let promise = this._deferredSave.saveChanges(); + if (!this._schemaVersionSet) { + this._schemaVersionSet = true; + promise = promise.then( + count => { + // Update the XPIDB schema version preference the first time we successfully + // save the database. + logger.debug("XPI Database saved, setting schema version preference to " + DB_SCHEMA); + Services.prefs.setIntPref(PREF_DB_SCHEMA, DB_SCHEMA); + // Reading the DB worked once, so we don't need the load error + this._loadError = null; + }, + error => { + // Need to try setting the schema version again later + this._schemaVersionSet = false; + // this._deferredSave.lastError has the most recent error so we don't + // need this any more + this._loadError = null; + + throw error; + }); + } + + promise.catch(error => { + logger.warn("Failed to save XPI database", error); + }); + }, + + flush: function() { + // handle the "in memory only" and "saveChanges never called" cases + if (!this._deferredSave) { + return Promise.resolve(0); + } + + return this._deferredSave.flush(); + }, + + /** + * Converts the current internal state of the XPI addon database to + * a JSON.stringify()-ready structure + */ + toJSON: function() { + if (!this.addonDB) { + // We never loaded the database? + throw new Error("Attempt to save database without loading it first"); + } + + let toSave = { + schemaVersion: DB_SCHEMA, + addons: [...this.addonDB.values()] + }; + return toSave; + }, + + /** + * Pull upgrade information from an existing SQLITE database + * + * @return false if there is no SQLITE database + * true and sets this.migrateData to null if the SQLITE DB exists + * but does not contain useful information + * true and sets this.migrateData to + * {location: {id1:{addon1}, id2:{addon2}}, location2:{...}, ...} + * if there is useful information + */ + getMigrateDataFromSQLITE: function() { + let connection = null; + let dbfile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_DATABASE], true); + // Attempt to open the database + try { + connection = Services.storage.openUnsharedDatabase(dbfile); + } + catch (e) { + logger.warn("Failed to open sqlite database " + dbfile.path + " for upgrade", e); + return null; + } + logger.debug("Migrating data from sqlite"); + let migrateData = this.getMigrateDataFromDatabase(connection); + connection.close(); + return migrateData; + }, + + /** + * Synchronously opens and reads the database file, upgrading from old + * databases or making a new DB if needed. + * + * The possibilities, in order of priority, are: + * 1) Perfectly good, up to date database + * 2) Out of date JSON database needs to be upgraded => upgrade + * 3) JSON database exists but is mangled somehow => build new JSON + * 4) no JSON DB, but a useable SQLITE db we can upgrade from => upgrade + * 5) useless SQLITE DB => build new JSON + * 6) useable RDF DB => upgrade + * 7) useless RDF DB => build new JSON + * 8) Nothing at all => build new JSON + * @param aRebuildOnError + * A boolean indicating whether add-on information should be loaded + * from the install locations if the database needs to be rebuilt. + * (if false, caller is XPIProvider.checkForChanges() which will rebuild) + */ + syncLoadDB: function(aRebuildOnError) { + this.migrateData = null; + let fstream = null; + let data = ""; + try { + let readTimer = AddonManagerPrivate.simpleTimer("XPIDB_syncRead_MS"); + logger.debug("Opening XPI database " + this.jsonFile.path); + fstream = Components.classes["@mozilla.org/network/file-input-stream;1"]. + createInstance(Components.interfaces.nsIFileInputStream); + fstream.init(this.jsonFile, -1, 0, 0); + let cstream = null; + try { + cstream = Components.classes["@mozilla.org/intl/converter-input-stream;1"]. + createInstance(Components.interfaces.nsIConverterInputStream); + cstream.init(fstream, "UTF-8", 0, 0); + + let str = {}; + let read = 0; + do { + read = cstream.readString(0xffffffff, str); // read as much as we can and put it in str.value + data += str.value; + } while (read != 0); + + readTimer.done(); + this.parseDB(data, aRebuildOnError); + } + catch (e) { + logger.error("Failed to load XPI JSON data from profile", e); + let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildReadFailed_MS"); + this.rebuildDatabase(aRebuildOnError); + rebuildTimer.done(); + } + finally { + if (cstream) + cstream.close(); + } + } + catch (e) { + if (e.result === Cr.NS_ERROR_FILE_NOT_FOUND) { + this.upgradeDB(aRebuildOnError); + } + else { + this.rebuildUnreadableDB(e, aRebuildOnError); + } + } + finally { + if (fstream) + fstream.close(); + } + // If an async load was also in progress, resolve that promise with our DB; + // otherwise create a resolved promise + if (this._dbPromise) { + AddonManagerPrivate.recordSimpleMeasure("XPIDB_overlapped_load", 1); + this._dbPromise.resolve(this.addonDB); + } + else + this._dbPromise = Promise.resolve(this.addonDB); + }, + + /** + * Parse loaded data, reconstructing the database if the loaded data is not valid + * @param aRebuildOnError + * If true, synchronously reconstruct the database from installed add-ons + */ + parseDB: function(aData, aRebuildOnError) { + let parseTimer = AddonManagerPrivate.simpleTimer("XPIDB_parseDB_MS"); + try { + // dump("Loaded JSON:\n" + aData + "\n"); + let inputAddons = JSON.parse(aData); + // Now do some sanity checks on our JSON db + if (!("schemaVersion" in inputAddons) || !("addons" in inputAddons)) { + parseTimer.done(); + // Content of JSON file is bad, need to rebuild from scratch + logger.error("bad JSON file contents"); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "badJSON"); + let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildBadJSON_MS"); + this.rebuildDatabase(aRebuildOnError); + rebuildTimer.done(); + return; + } + if (inputAddons.schemaVersion != DB_SCHEMA) { + // Handle mismatched JSON schema version. For now, we assume + // compatibility for JSON data, though we throw away any fields we + // don't know about (bug 902956) + AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", + "schemaMismatch-" + inputAddons.schemaVersion); + logger.debug("JSON schema mismatch: expected " + DB_SCHEMA + + ", actual " + inputAddons.schemaVersion); + // When we rev the schema of the JSON database, we need to make sure we + // force the DB to save so that the DB_SCHEMA value in the JSON file and + // the preference are updated. + } + // If we got here, we probably have good data + // Make AddonInternal instances from the loaded data and save them + let addonDB = new Map(); + for (let loadedAddon of inputAddons.addons) { + loadedAddon._sourceBundle = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + try { + loadedAddon._sourceBundle.persistentDescriptor = loadedAddon.descriptor; + } + catch (e) { + // We can fail here when the descriptor is invalid, usually from the + // wrong OS + logger.warn("Could not find source bundle for add-on " + loadedAddon.id, e); + } + + let newAddon = new DBAddonInternal(loadedAddon); + addonDB.set(newAddon._key, newAddon); + } + parseTimer.done(); + this.addonDB = addonDB; + logger.debug("Successfully read XPI database"); + this.initialized = true; + } + catch (e) { + // If we catch and log a SyntaxError from the JSON + // parser, the xpcshell test harness fails the test for us: bug 870828 + parseTimer.done(); + if (e.name == "SyntaxError") { + logger.error("Syntax error parsing saved XPI JSON data"); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "syntax"); + } + else { + logger.error("Failed to load XPI JSON data from profile", e); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "other"); + } + let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildReadFailed_MS"); + this.rebuildDatabase(aRebuildOnError); + rebuildTimer.done(); + } + }, + + /** + * Upgrade database from earlier (sqlite or RDF) version if available + */ + upgradeDB: function(aRebuildOnError) { + let upgradeTimer = AddonManagerPrivate.simpleTimer("XPIDB_upgradeDB_MS"); + try { + let schemaVersion = Services.prefs.getIntPref(PREF_DB_SCHEMA); + if (schemaVersion <= LAST_SQLITE_DB_SCHEMA) { + // we should have an older SQLITE database + logger.debug("Attempting to upgrade from SQLITE database"); + this.migrateData = this.getMigrateDataFromSQLITE(); + } + else { + // we've upgraded before but the JSON file is gone, fall through + // and rebuild from scratch + AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "dbMissing"); + } + } + catch (e) { + // No schema version pref means either a really old upgrade (RDF) or + // a new profile + this.migrateData = this.getMigrateDataFromRDF(); + } + + this.rebuildDatabase(aRebuildOnError); + upgradeTimer.done(); + }, + + /** + * Reconstruct when the DB file exists but is unreadable + * (for example because read permission is denied) + */ + rebuildUnreadableDB: function(aError, aRebuildOnError) { + let rebuildTimer = AddonManagerPrivate.simpleTimer("XPIDB_rebuildUnreadableDB_MS"); + logger.warn("Extensions database " + this.jsonFile.path + + " exists but is not readable; rebuilding", aError); + // Remember the error message until we try and write at least once, so + // we know at shutdown time that there was a problem + this._loadError = aError; + AddonManagerPrivate.recordSimpleMeasure("XPIDB_startupError", "unreadable"); + this.rebuildDatabase(aRebuildOnError); + rebuildTimer.done(); + }, + + /** + * Open and read the XPI database asynchronously, upgrading if + * necessary. If any DB load operation fails, we need to + * synchronously rebuild the DB from the installed extensions. + * + * @return Promise resolves to the Map of loaded JSON data stored + * in this.addonDB; never rejects. + */ + asyncLoadDB: function() { + // Already started (and possibly finished) loading + if (this._dbPromise) { + return this._dbPromise; + } + + logger.debug("Starting async load of XPI database " + this.jsonFile.path); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_async_load", XPIProvider.runPhase); + let readOptions = { + outExecutionDuration: 0 + }; + return this._dbPromise = OS.File.read(this.jsonFile.path, null, readOptions).then( + byteArray => { + logger.debug("Async JSON file read took " + readOptions.outExecutionDuration + " MS"); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_asyncRead_MS", + readOptions.outExecutionDuration); + if (this._addonDB) { + logger.debug("Synchronous load completed while waiting for async load"); + return this.addonDB; + } + logger.debug("Finished async read of XPI database, parsing..."); + let decodeTimer = AddonManagerPrivate.simpleTimer("XPIDB_decode_MS"); + let decoder = new TextDecoder(); + let data = decoder.decode(byteArray); + decodeTimer.done(); + this.parseDB(data, true); + return this.addonDB; + }) + .then(null, + error => { + if (this._addonDB) { + logger.debug("Synchronous load completed while waiting for async load"); + return this.addonDB; + } + if (error.becauseNoSuchFile) { + this.upgradeDB(true); + } + else { + // it's there but unreadable + this.rebuildUnreadableDB(error, true); + } + return this.addonDB; + }); + }, + + /** + * Rebuild the database from addon install directories. If this.migrateData + * is available, uses migrated information for settings on the addons found + * during rebuild + * @param aRebuildOnError + * A boolean indicating whether add-on information should be loaded + * from the install locations if the database needs to be rebuilt. + * (if false, caller is XPIProvider.checkForChanges() which will rebuild) + */ + rebuildDatabase: function(aRebuildOnError) { + this.addonDB = new Map(); + this.initialized = true; + + if (XPIStates.size == 0) { + // No extensions installed, so we're done + logger.debug("Rebuilding XPI database with no extensions"); + return; + } + + // If there is no migration data then load the list of add-on directories + // that were active during the last run + if (!this.migrateData) + this.activeBundles = this.getActiveBundles(); + + if (aRebuildOnError) { + logger.warn("Rebuilding add-ons database from installed extensions."); + try { + XPIDatabaseReconcile.processFileChanges({}, false); + } + catch (e) { + logger.error("Failed to rebuild XPI database from installed extensions", e); + } + // Make sure to update the active add-ons and add-ons list on shutdown + Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true); + } + }, + + /** + * Gets the list of file descriptors of active extension directories or XPI + * files from the add-ons list. This must be loaded from disk since the + * directory service gives no easy way to get both directly. This list doesn't + * include themes as preferences already say which theme is currently active + * + * @return an array of persistent descriptors for the directories + */ + getActiveBundles: function() { + let bundles = []; + + // non-bootstrapped extensions + let addonsList = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST], + true); + + if (!addonsList.exists()) + // XXX Irving believes this is broken in the case where there is no + // extensions.ini but there are bootstrap extensions (e.g. Android) + return null; + + try { + let iniFactory = Cc["@mozilla.org/xpcom/ini-parser-factory;1"] + .getService(Ci.nsIINIParserFactory); + let parser = iniFactory.createINIParser(addonsList); + let keys = parser.getKeys("ExtensionDirs"); + + while (keys.hasMore()) + bundles.push(parser.getString("ExtensionDirs", keys.getNext())); + } + catch (e) { + logger.warn("Failed to parse extensions.ini", e); + return null; + } + + // Also include the list of active bootstrapped extensions + for (let id in XPIProvider.bootstrappedAddons) + bundles.push(XPIProvider.bootstrappedAddons[id].descriptor); + + return bundles; + }, + + /** + * Retrieves migration data from the old extensions.rdf database. + * + * @return an object holding information about what add-ons were previously + * userDisabled and any updated compatibility information + */ + getMigrateDataFromRDF: function(aDbWasMissing) { + + // Migrate data from extensions.rdf + let rdffile = FileUtils.getFile(KEY_PROFILEDIR, [FILE_OLD_DATABASE], true); + if (!rdffile.exists()) + return null; + + logger.debug("Migrating data from " + FILE_OLD_DATABASE); + let migrateData = {}; + + try { + let ds = gRDF.GetDataSourceBlocking(Services.io.newFileURI(rdffile).spec); + let root = Cc["@mozilla.org/rdf/container;1"]. + createInstance(Ci.nsIRDFContainer); + root.Init(ds, gRDF.GetResource(RDFURI_ITEM_ROOT)); + let elements = root.GetElements(); + + while (elements.hasMoreElements()) { + let source = elements.getNext().QueryInterface(Ci.nsIRDFResource); + + let location = getRDFProperty(ds, source, "installLocation"); + if (location) { + if (!(location in migrateData)) + migrateData[location] = {}; + let id = source.ValueUTF8.substring(PREFIX_ITEM_URI.length); + migrateData[location][id] = { + version: getRDFProperty(ds, source, "version"), + userDisabled: false, + targetApplications: [] + } + + let disabled = getRDFProperty(ds, source, "userDisabled"); + if (disabled == "true" || disabled == "needs-disable") + migrateData[location][id].userDisabled = true; + + let targetApps = ds.GetTargets(source, EM_R("targetApplication"), + true); + while (targetApps.hasMoreElements()) { + let targetApp = targetApps.getNext() + .QueryInterface(Ci.nsIRDFResource); + let appInfo = { + id: getRDFProperty(ds, targetApp, "id") + }; + + let minVersion = getRDFProperty(ds, targetApp, "updatedMinVersion"); + if (minVersion) { + appInfo.minVersion = minVersion; + appInfo.maxVersion = getRDFProperty(ds, targetApp, "updatedMaxVersion"); + } + else { + appInfo.minVersion = getRDFProperty(ds, targetApp, "minVersion"); + appInfo.maxVersion = getRDFProperty(ds, targetApp, "maxVersion"); + } + migrateData[location][id].targetApplications.push(appInfo); + } + } + } + } + catch (e) { + logger.warn("Error reading " + FILE_OLD_DATABASE, e); + migrateData = null; + } + + return migrateData; + }, + + /** + * Retrieves migration data from a database that has an older or newer schema. + * + * @return an object holding information about what add-ons were previously + * userDisabled and any updated compatibility information + */ + getMigrateDataFromDatabase: function(aConnection) { + let migrateData = {}; + + // Attempt to migrate data from a different (even future!) version of the + // database + try { + var stmt = aConnection.createStatement("PRAGMA table_info(addon)"); + + const REQUIRED = ["internal_id", "id", "location", "userDisabled", + "installDate", "version"]; + + let reqCount = 0; + let props = []; + for (let row of resultRows(stmt)) { + if (REQUIRED.indexOf(row.name) != -1) { + reqCount++; + props.push(row.name); + } + else if (DB_METADATA.indexOf(row.name) != -1) { + props.push(row.name); + } + else if (DB_BOOL_METADATA.indexOf(row.name) != -1) { + props.push(row.name); + } + } + + if (reqCount < REQUIRED.length) { + logger.error("Unable to read anything useful from the database"); + return null; + } + stmt.finalize(); + + stmt = aConnection.createStatement("SELECT " + props.join(",") + " FROM addon"); + for (let row of resultRows(stmt)) { + if (!(row.location in migrateData)) + migrateData[row.location] = {}; + let addonData = { + targetApplications: [] + } + migrateData[row.location][row.id] = addonData; + + props.forEach(function(aProp) { + if (aProp == "isForeignInstall") + addonData.foreignInstall = (row[aProp] == 1); + if (DB_BOOL_METADATA.indexOf(aProp) != -1) + addonData[aProp] = row[aProp] == 1; + else + addonData[aProp] = row[aProp]; + }) + } + + var taStmt = aConnection.createStatement("SELECT id, minVersion, " + + "maxVersion FROM " + + "targetApplication WHERE " + + "addon_internal_id=:internal_id"); + + for (let location in migrateData) { + for (let id in migrateData[location]) { + taStmt.params.internal_id = migrateData[location][id].internal_id; + delete migrateData[location][id].internal_id; + for (let row of resultRows(taStmt)) { + migrateData[location][id].targetApplications.push({ + id: row.id, + minVersion: row.minVersion, + maxVersion: row.maxVersion + }); + } + } + } + } + catch (e) { + // An error here means the schema is too different to read + logger.error("Error migrating data", e); + return null; + } + finally { + if (taStmt) + taStmt.finalize(); + if (stmt) + stmt.finalize(); + } + + return migrateData; + }, + + /** + * Shuts down the database connection and releases all cached objects. + * Return: Promise{integer} resolves / rejects with the result of the DB + * flush after the database is flushed and + * all cleanup is done + */ + shutdown: function() { + logger.debug("shutdown"); + if (this.initialized) { + // If our last database I/O had an error, try one last time to save. + if (this.lastError) + this.saveChanges(); + + this.initialized = false; + + if (this._deferredSave) { + AddonManagerPrivate.recordSimpleMeasure( + "XPIDB_saves_total", this._deferredSave.totalSaves); + AddonManagerPrivate.recordSimpleMeasure( + "XPIDB_saves_overlapped", this._deferredSave.overlappedSaves); + AddonManagerPrivate.recordSimpleMeasure( + "XPIDB_saves_late", this._deferredSave.dirty ? 1 : 0); + } + + // Return a promise that any pending writes of the DB are complete and we + // are finished cleaning up + let flushPromise = this.flush(); + flushPromise.then(null, error => { + logger.error("Flush of XPI database failed", error); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_shutdownFlush_failed", 1); + // If our last attempt to read or write the DB failed, force a new + // extensions.ini to be written to disk on the next startup + Services.prefs.setBoolPref(PREF_PENDING_OPERATIONS, true); + }) + .then(count => { + // Clear out the cached addons data loaded from JSON + delete this.addonDB; + delete this._dbPromise; + // same for the deferred save + delete this._deferredSave; + // re-enable the schema version setter + delete this._schemaVersionSet; + }); + return flushPromise; + } + return Promise.resolve(0); + }, + + /** + * Asynchronously list all addons that match the filter function + * @param aFilter + * Function that takes an addon instance and returns + * true if that addon should be included in the selected array + * @param aCallback + * Called back with an array of addons matching aFilter + * or an empty array if none match + */ + getAddonList: function(aFilter, aCallback) { + this.asyncLoadDB().then( + addonDB => { + let addonList = _filterDB(addonDB, aFilter); + asyncMap(addonList, getRepositoryAddon, makeSafe(aCallback)); + }) + .then(null, + error => { + logger.error("getAddonList failed", error); + makeSafe(aCallback)([]); + }); + }, + + /** + * (Possibly asynchronously) get the first addon that matches the filter function + * @param aFilter + * Function that takes an addon instance and returns + * true if that addon should be selected + * @param aCallback + * Called back with the addon, or null if no matching addon is found + */ + getAddon: function(aFilter, aCallback) { + return this.asyncLoadDB().then( + addonDB => { + getRepositoryAddon(_findAddon(addonDB, aFilter), makeSafe(aCallback)); + }) + .then(null, + error => { + logger.error("getAddon failed", error); + makeSafe(aCallback)(null); + }); + }, + + /** + * Asynchronously gets an add-on with a particular ID in a particular + * install location. + * + * @param aId + * The ID of the add-on to retrieve + * @param aLocation + * The name of the install location + * @param aCallback + * A callback to pass the DBAddonInternal to + */ + getAddonInLocation: function(aId, aLocation, aCallback) { + this.asyncLoadDB().then( + addonDB => getRepositoryAddon(addonDB.get(aLocation + ":" + aId), + makeSafe(aCallback))); + }, + + /** + * Asynchronously get all the add-ons in a particular install location. + * + * @param aLocation + * The name of the install location + * @param aCallback + * A callback to pass the array of DBAddonInternals to + */ + getAddonsInLocation: function(aLocation, aCallback) { + this.getAddonList(aAddon => aAddon._installLocation.name == aLocation, aCallback); + }, + + /** + * Asynchronously gets the add-on with the specified ID that is visible. + * + * @param aId + * The ID of the add-on to retrieve + * @param aCallback + * A callback to pass the DBAddonInternal to + */ + getVisibleAddonForID: function(aId, aCallback) { + this.getAddon(aAddon => ((aAddon.id == aId) && aAddon.visible), + aCallback); + }, + + /** + * Asynchronously gets the visible add-ons, optionally restricting by type. + * + * @param aTypes + * An array of types to include or null to include all types + * @param aCallback + * A callback to pass the array of DBAddonInternals to + */ + getVisibleAddons: function(aTypes, aCallback) { + this.getAddonList(aAddon => (aAddon.visible && + (!aTypes || (aTypes.length == 0) || + (aTypes.indexOf(aAddon.type) > -1))), + aCallback); + }, + + /** + * Synchronously gets all add-ons of a particular type. + * + * @param aType + * The type of add-on to retrieve + * @return an array of DBAddonInternals + */ + getAddonsByType: function(aType) { + if (!this.addonDB) { + // jank-tastic! Must synchronously load DB if the theme switches from + // an XPI theme to a lightweight theme before the DB has loaded, + // because we're called from sync XPIProvider.addonChanged + logger.warn("Synchronous load of XPI database due to getAddonsByType(" + aType + ")"); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_byType", XPIProvider.runPhase); + this.syncLoadDB(true); + } + return _filterDB(this.addonDB, aAddon => (aAddon.type == aType)); + }, + + /** + * Synchronously gets an add-on with a particular internalName. + * + * @param aInternalName + * The internalName of the add-on to retrieve + * @return a DBAddonInternal + */ + getVisibleAddonForInternalName: function(aInternalName) { + if (!this.addonDB) { + // This may be called when the DB hasn't otherwise been loaded + logger.warn("Synchronous load of XPI database due to getVisibleAddonForInternalName"); + AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_forInternalName", + XPIProvider.runPhase); + this.syncLoadDB(true); + } + + return _findAddon(this.addonDB, + aAddon => aAddon.visible && + (aAddon.internalName == aInternalName)); + }, + + /** + * Asynchronously gets all add-ons with pending operations. + * + * @param aTypes + * The types of add-ons to retrieve or null to get all types + * @param aCallback + * A callback to pass the array of DBAddonInternal to + */ + getVisibleAddonsWithPendingOperations: function(aTypes, aCallback) { + this.getAddonList( + aAddon => (aAddon.visible && + (aAddon.pendingUninstall || + // Logic here is tricky. If we're active but disabled, + // we're pending disable; !active && !disabled, we're pending enable + (aAddon.active == aAddon.disabled)) && + (!aTypes || (aTypes.length == 0) || (aTypes.indexOf(aAddon.type) > -1))), + aCallback); + }, + + /** + * Asynchronously get an add-on by its Sync GUID. + * + * @param aGUID + * Sync GUID of add-on to fetch + * @param aCallback + * A callback to pass the DBAddonInternal record to. Receives null + * if no add-on with that GUID is found. + * + */ + getAddonBySyncGUID: function(aGUID, aCallback) { + this.getAddon(aAddon => aAddon.syncGUID == aGUID, + aCallback); + }, + + /** + * Synchronously gets all add-ons in the database. + * This is only called from the preference observer for the default + * compatibility version preference, so we can return an empty list if + * we haven't loaded the database yet. + * + * @return an array of DBAddonInternals + */ + getAddons: function() { + if (!this.addonDB) { + return []; + } + return _filterDB(this.addonDB, aAddon => true); + }, + + /** + * Synchronously adds an AddonInternal's metadata to the database. + * + * @param aAddon + * AddonInternal to add + * @param aDescriptor + * The file descriptor of the add-on + * @return The DBAddonInternal that was added to the database + */ + addAddonMetadata: function(aAddon, aDescriptor) { + if (!this.addonDB) { + AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_addMetadata", + XPIProvider.runPhase); + this.syncLoadDB(false); + } + + let newAddon = new DBAddonInternal(aAddon); + newAddon.descriptor = aDescriptor; + this.addonDB.set(newAddon._key, newAddon); + if (newAddon.visible) { + this.makeAddonVisible(newAddon); + } + + this.saveChanges(); + return newAddon; + }, + + /** + * Synchronously updates an add-on's metadata in the database. Currently just + * removes and recreates. + * + * @param aOldAddon + * The DBAddonInternal to be replaced + * @param aNewAddon + * The new AddonInternal to add + * @param aDescriptor + * The file descriptor of the add-on + * @return The DBAddonInternal that was added to the database + */ + updateAddonMetadata: function(aOldAddon, aNewAddon, aDescriptor) { + this.removeAddonMetadata(aOldAddon); + aNewAddon.syncGUID = aOldAddon.syncGUID; + aNewAddon.installDate = aOldAddon.installDate; + aNewAddon.applyBackgroundUpdates = aOldAddon.applyBackgroundUpdates; + aNewAddon.foreignInstall = aOldAddon.foreignInstall; + aNewAddon.seen = aOldAddon.seen; + aNewAddon.active = (aNewAddon.visible && !aNewAddon.disabled && !aNewAddon.pendingUninstall); + + // addAddonMetadata does a saveChanges() + return this.addAddonMetadata(aNewAddon, aDescriptor); + }, + + /** + * Synchronously removes an add-on from the database. + * + * @param aAddon + * The DBAddonInternal being removed + */ + removeAddonMetadata: function(aAddon) { + this.addonDB.delete(aAddon._key); + this.saveChanges(); + }, + + /** + * Synchronously marks a DBAddonInternal as visible marking all other + * instances with the same ID as not visible. + * + * @param aAddon + * The DBAddonInternal to make visible + */ + makeAddonVisible: function(aAddon) { + logger.debug("Make addon " + aAddon._key + " visible"); + for (let [, otherAddon] of this.addonDB) { + if ((otherAddon.id == aAddon.id) && (otherAddon._key != aAddon._key)) { + logger.debug("Hide addon " + otherAddon._key); + otherAddon.visible = false; + otherAddon.active = false; + } + } + aAddon.visible = true; + this.saveChanges(); + }, + + /** + * Synchronously sets properties for an add-on. + * + * @param aAddon + * The DBAddonInternal being updated + * @param aProperties + * A dictionary of properties to set + */ + setAddonProperties: function(aAddon, aProperties) { + for (let key in aProperties) { + aAddon[key] = aProperties[key]; + } + this.saveChanges(); + }, + + /** + * Synchronously sets the Sync GUID for an add-on. + * Only called when the database is already loaded. + * + * @param aAddon + * The DBAddonInternal being updated + * @param aGUID + * GUID string to set the value to + * @throws if another addon already has the specified GUID + */ + setAddonSyncGUID: function(aAddon, aGUID) { + // Need to make sure no other addon has this GUID + function excludeSyncGUID(otherAddon) { + return (otherAddon._key != aAddon._key) && (otherAddon.syncGUID == aGUID); + } + let otherAddon = _findAddon(this.addonDB, excludeSyncGUID); + if (otherAddon) { + throw new Error("Addon sync GUID conflict for addon " + aAddon._key + + ": " + otherAddon._key + " already has GUID " + aGUID); + } + aAddon.syncGUID = aGUID; + this.saveChanges(); + }, + + /** + * Synchronously updates an add-on's active flag in the database. + * + * @param aAddon + * The DBAddonInternal to update + */ + updateAddonActive: function(aAddon, aActive) { + logger.debug("Updating active state for add-on " + aAddon.id + " to " + aActive); + + aAddon.active = aActive; + this.saveChanges(); + }, + + updateAddonsBlockingE10s: function() { + let blockE10s = false; + + Preferences.set(PREF_E10S_HAS_NONEXEMPT_ADDON, false); + for (let [, addon] of this.addonDB) { + let active = (addon.visible && !addon.disabled && !addon.pendingUninstall); + + if (active && XPIProvider.isBlockingE10s(addon)) { + blockE10s = true; + break; + } + } + Preferences.set(PREF_E10S_BLOCKED_BY_ADDONS, blockE10s); + }, + + /** + * Synchronously calculates and updates all the active flags in the database. + */ + updateActiveAddons: function() { + if (!this.addonDB) { + logger.warn("updateActiveAddons called when DB isn't loaded"); + // force the DB to load + AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_updateActive", + XPIProvider.runPhase); + this.syncLoadDB(true); + } + logger.debug("Updating add-on states"); + for (let [, addon] of this.addonDB) { + let newActive = (addon.visible && !addon.disabled && !addon.pendingUninstall); + if (newActive != addon.active) { + addon.active = newActive; + this.saveChanges(); + } + } + }, + + /** + * Writes out the XPI add-ons list for the platform to read. + * @return true if the file was successfully updated, false otherwise + */ + writeAddonsList: function() { + if (!this.addonDB) { + // force the DB to load + AddonManagerPrivate.recordSimpleMeasure("XPIDB_lateOpen_writeList", + XPIProvider.runPhase); + this.syncLoadDB(true); + } + Services.appinfo.invalidateCachesOnRestart(); + + let addonsList = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST], + true); + let enabledAddons = []; + let text = "[ExtensionDirs]\r\n"; + let count = 0; + let fullCount = 0; + + let activeAddons = _filterDB( + this.addonDB, + aAddon => aAddon.active && !aAddon.bootstrap && (aAddon.type != "theme")); + + for (let row of activeAddons) { + text += "Extension" + (count++) + "=" + row.descriptor + "\r\n"; + enabledAddons.push(encodeURIComponent(row.id) + ":" + + encodeURIComponent(row.version)); + } + fullCount += count; + + // The selected skin may come from an inactive theme (the default theme + // when a lightweight theme is applied for example) + text += "\r\n[ThemeDirs]\r\n"; + + let dssEnabled = false; + try { + dssEnabled = Services.prefs.getBoolPref(PREF_EM_DSS_ENABLED); + } catch (e) {} + + let themes = []; + if (dssEnabled) { + themes = _filterDB(this.addonDB, aAddon => aAddon.type == "theme"); + } + else { + let activeTheme = _findAddon( + this.addonDB, + aAddon => (aAddon.type == "theme") && + (aAddon.internalName == XPIProvider.selectedSkin)); + if (activeTheme) { + themes.push(activeTheme); + } + } + + if (themes.length > 0) { + count = 0; + for (let row of themes) { + text += "Extension" + (count++) + "=" + row.descriptor + "\r\n"; + enabledAddons.push(encodeURIComponent(row.id) + ":" + + encodeURIComponent(row.version)); + } + fullCount += count; + } + + text += "\r\n[MultiprocessIncompatibleExtensions]\r\n"; + + count = 0; + for (let row of activeAddons) { + if (!row.multiprocessCompatible) { + text += "Extension" + (count++) + "=" + row.id + "\r\n"; + } + } + + if (fullCount > 0) { + logger.debug("Writing add-ons list"); + + try { + let addonsListTmp = FileUtils.getFile(KEY_PROFILEDIR, [FILE_XPI_ADDONS_LIST + ".tmp"], + true); + var fos = FileUtils.openFileOutputStream(addonsListTmp); + fos.write(text, text.length); + fos.close(); + addonsListTmp.moveTo(addonsListTmp.parent, FILE_XPI_ADDONS_LIST); + + Services.prefs.setCharPref(PREF_EM_ENABLED_ADDONS, enabledAddons.join(",")); + } + catch (e) { + logger.error("Failed to write add-ons list to profile directory", e); + return false; + } + } + else { + if (addonsList.exists()) { + logger.debug("Deleting add-ons list"); + try { + addonsList.remove(false); + } + catch (e) { + logger.error("Failed to remove " + addonsList.path, e); + return false; + } + } + + Services.prefs.clearUserPref(PREF_EM_ENABLED_ADDONS); + } + return true; + } +}; + +this.XPIDatabaseReconcile = { + /** + * Returns a map of ID -> add-on. When the same add-on ID exists in multiple + * install locations the highest priority location is chosen. + */ + flattenByID(addonMap, hideLocation) { + let map = new Map(); + + for (let installLocation of XPIProvider.installLocations) { + if (installLocation.name == hideLocation) + continue; + + let locationMap = addonMap.get(installLocation.name); + if (!locationMap) + continue; + + for (let [id, addon] of locationMap) { + if (!map.has(id)) + map.set(id, addon); + } + } + + return map; + }, + + /** + * Finds the visible add-ons from the map. + */ + getVisibleAddons(addonMap) { + let map = new Map(); + + for (let [location, addons] of addonMap) { + for (let [id, addon] of addons) { + if (!addon.visible) + continue; + + if (map.has(id)) { + logger.warn("Previous database listed more than one visible add-on with id " + id); + continue; + } + + map.set(id, addon); + } + } + + return map; + }, + + /** + * 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 aNewAddon + * The manifest for the new add-on if it has already been loaded + * @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 + * @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 + */ + addMetadata(aInstallLocation, aId, aAddonState, aNewAddon, aOldAppVersion, + aOldPlatformVersion, aMigrateData) { + logger.debug("New add-on " + aId + " installed in " + aInstallLocation.name); + + // 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 = (!!aNewAddon) || (!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 && !aNewAddon; + + // Load the manifest if necessary and sanity check the add-on ID + try { + if (!aNewAddon) { + // Load the manifest from the add-on. + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.persistentDescriptor = aAddonState.descriptor; + aNewAddon = syncLoadManifestFromFile(file, aInstallLocation); + } + // The add-on in the manifest should match the add-on ID. + if (aNewAddon.id != aId) { + throw new Error("Invalid addon ID: expected addon ID " + aId + + ", found " + aNewAddon.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.isLinkedAddon(aId)) + logger.warn("Not uninstalling invalid item because it is a proxy file"); + else if (aInstallLocation.locked) + logger.warn("Could not uninstall invalid item from locked install location"); + else + aInstallLocation.uninstallAddon(aId); + return null; + } + + // Update the AddonInternal properties. + aNewAddon.installDate = aAddonState.mtime; + aNewAddon.updateDate = aAddonState.mtime; + + // Assume that add-ons in the system add-ons install location aren't + // foreign and should default to enabled. + aNewAddon.foreignInstall = isDetectedInstall && + aInstallLocation.name != KEY_APP_SYSTEM_ADDONS && + aInstallLocation.name != KEY_APP_SYSTEM_DEFAULTS; + + // appDisabled depends on whether the add-on is a foreignInstall so update + aNewAddon.appDisabled = !isUsableAddon(aNewAddon); + + 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" && aNewAddon.type == "theme") + return; + + if (aProp in aMigrateData) + aNewAddon[aProp] = aMigrateData[aProp]; + }); + + // Force all non-profile add-ons to be foreignInstalls since they can't + // have been installed through the API + aNewAddon.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 == aNewAddon.version) { + logger.debug("Migrating compatibility info"); + if ("targetApplications" in aMigrateData) + aNewAddon.applyCompatibilityUpdate(aMigrateData, true); + } + + // Since the DB schema has changed make sure softDisabled is correct + applyBlocklistChanges(aNewAddon, aNewAddon, aOldAppVersion, + aOldPlatformVersion); + } + + // The default theme is never a foreign install + if (aNewAddon.type == "theme" && aNewAddon.internalName == XPIProvider.defaultSkin) + aNewAddon.foreignInstall = false; + + if (isDetectedInstall && aNewAddon.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 " + aNewAddon.id + " in " + + aInstallLocation.name); + aNewAddon.userDisabled = true; + + // If we don't have an old app version then this is a new profile in + // which case just mark any sideloaded add-ons as already seen. + aNewAddon.seen = !aOldAppVersion; + } + } + + return XPIDatabase.addAddonMetadata(aNewAddon, aAddonState.descriptor); + }, + + /** + * 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 + */ + removeMetadata(aOldAddon) { + // This add-on has disappeared + logger.debug("Add-on " + aOldAddon.id + " removed from " + aOldAddon.location); + XPIDatabase.removeAddonMetadata(aOldAddon); + }, + + /** + * 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 + * @param aNewAddon + * The manifest for the new add-on if it has already been loaded + * @return a boolean indicating if flushing caches is required to complete + * changing this add-on + */ + updateMetadata(aInstallLocation, aOldAddon, aAddonState, aNewAddon) { + logger.debug("Add-on " + aOldAddon.id + " modified in " + aInstallLocation.name); + + try { + // If there isn't an updated install manifest for this add-on then load it. + if (!aNewAddon) { + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.persistentDescriptor = aAddonState.descriptor; + aNewAddon = syncLoadManifestFromFile(file, aInstallLocation); + applyBlocklistChanges(aOldAddon, aNewAddon); + + // 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. + aNewAddon.pendingUninstall = aOldAddon.pendingUninstall; + } + + // The ID in the manifest that was loaded must match the ID of the old + // add-on. + if (aNewAddon.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"); + + return null; + } + + // Set the additional properties on the new AddonInternal + aNewAddon.updateDate = aAddonState.mtime; + + // Update the database + return XPIDatabase.updateAddonMetadata(aOldAddon, aNewAddon, aAddonState.descriptor); + }, + + /** + * 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 + */ + updateDescriptor(aInstallLocation, aOldAddon, aAddonState) { + logger.debug("Add-on " + aOldAddon.id + " moved to " + aAddonState.descriptor); + aOldAddon.descriptor = aAddonState.descriptor; + aOldAddon._sourceBundle.persistentDescriptor = aAddonState.descriptor; + + return aOldAddon; + }, + + /** + * Called when no change has been detected for an add-on's metadata but the + * application has changed so compatibility may have 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 + * @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 + * @param aReloadMetadata + * A boolean which indicates whether metadata should be reloaded from + * the addon manifests. Default to false. + * @return the new addon. + */ + updateCompatibility(aInstallLocation, aOldAddon, aAddonState, aOldAppVersion, + aOldPlatformVersion, aReloadMetadata) { + logger.debug("Updating compatibility for add-on " + aOldAddon.id + " in " + aInstallLocation.name); + + // If updating from a version of the app that didn't support signedState + // then fetch that property now + if (aOldAddon.signedState === undefined && ADDON_SIGNING && + SIGNED_TYPES.has(aOldAddon.type)) { + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.persistentDescriptor = aAddonState.descriptor; + let manifest = syncLoadManifestFromFile(file, aInstallLocation); + aOldAddon.signedState = manifest.signedState; + } + + // May be updating from a version of the app that didn't support all the + // properties of the currently-installed add-ons. + if (aReloadMetadata) { + let file = new nsIFile() + file.persistentDescriptor = aAddonState.descriptor; + let manifest = syncLoadManifestFromFile(file, aInstallLocation); + + // Avoid re-reading these properties from manifest, + // use existing addon instead. + // TODO - consider re-scanning for targetApplications. + let remove = ["syncGUID", "foreignInstall", "visible", "active", + "userDisabled", "applyBackgroundUpdates", "sourceURI", + "releaseNotesURI", "targetApplications"]; + + let props = PROP_JSON_FIELDS.filter(a => !remove.includes(a)); + copyProperties(manifest, props, aOldAddon); + } + + // This updates the addon's JSON cached data in place + applyBlocklistChanges(aOldAddon, aOldAddon, aOldAppVersion, + aOldPlatformVersion); + aOldAddon.appDisabled = !isUsableAddon(aOldAddon); + + return aOldAddon; + }, + + /** + * 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 + * @param aSchemaChange + * The schema has changed and all add-on manifests should be re-read. + * @return a boolean indicating if a change requiring flushing the caches was + * detected + */ + processFileChanges(aManifests, aUpdateCompatibility, aOldAppVersion, aOldPlatformVersion, + aSchemaChange) { + let loadedManifest = (aInstallLocation, aId) => { + if (!(aInstallLocation.name in aManifests)) + return null; + if (!(aId in aManifests[aInstallLocation.name])) + return null; + return aManifests[aInstallLocation.name][aId]; + }; + + // Add-ons loaded from the database can have an uninitialized _sourceBundle + // if the descriptor was invalid. Swallow that error and say they don't exist. + let exists = (aAddon) => { + try { + return aAddon._sourceBundle.exists(); + } + catch (e) { + if (e.result == Cr.NS_ERROR_NOT_INITIALIZED) + return false; + throw e; + } + }; + + // Get the previous add-ons from the database and put them into maps by location + let previousAddons = new Map(); + for (let a of XPIDatabase.getAddons()) { + let locationAddonMap = previousAddons.get(a.location); + if (!locationAddonMap) { + locationAddonMap = new Map(); + previousAddons.set(a.location, locationAddonMap); + } + locationAddonMap.set(a.id, a); + } + + // Build the list of current add-ons into similar maps. When add-ons are still + // present we re-use the add-on objects from the database and update their + // details directly + let currentAddons = new Map(); + for (let installLocation of XPIProvider.installLocations) { + let locationAddonMap = new Map(); + currentAddons.set(installLocation.name, locationAddonMap); + + // 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); + + // Iterate through the add-ons installed the last time the application + // ran + let dbAddons = previousAddons.get(installLocation.name); + if (dbAddons) { + for (let [id, oldAddon] of dbAddons) { + // Check if the add-on is still installed + let xpiState = states && states.get(id); + if (xpiState) { + // Here the add-on was present in the database and on disk + recordAddonTelemetry(oldAddon); + + // Check if the add-on has been changed outside the XPI provider + if (oldAddon.updateDate != xpiState.mtime) { + // Did time change in the wrong direction? + if (xpiState.mtime < oldAddon.updateDate) { + XPIProvider.setTelemetry(oldAddon.id, "olderFile", { + name: XPIProvider._mostRecentlyModifiedFile[id], + mtime: xpiState.mtime, + oldtime: oldAddon.updateDate + }); + } else { + XPIProvider.setTelemetry(oldAddon.id, "modifiedFile", + XPIProvider._mostRecentlyModifiedFile[id]); + } + } + + // The add-on has changed if the modification time has changed, if + // we have an updated manifest for it, or if the schema version has + // changed. + // + // Also reload the metadata for add-ons in the application directory + // when the application version has changed. + let newAddon = loadedManifest(installLocation, id); + if (newAddon || oldAddon.updateDate != xpiState.mtime || + (aUpdateCompatibility && (installLocation.name == KEY_APP_GLOBAL || + installLocation.name == KEY_APP_SYSTEM_DEFAULTS))) { + newAddon = this.updateMetadata(installLocation, oldAddon, xpiState, newAddon); + } + else if (oldAddon.descriptor != xpiState.descriptor) { + newAddon = this.updateDescriptor(installLocation, oldAddon, xpiState); + } + // Check compatility when the application version and/or schema + // version has changed. A schema change also reloads metadata from + // the manifests. + else if (aUpdateCompatibility || aSchemaChange) { + newAddon = this.updateCompatibility(installLocation, oldAddon, xpiState, + aOldAppVersion, aOldPlatformVersion, + aSchemaChange); + } + else { + // No change + newAddon = oldAddon; + } + + if (newAddon) + locationAddonMap.set(newAddon.id, newAddon); + } + else { + // The add-on is in the DB, but not in xpiState (and thus not on disk). + this.removeMetadata(oldAddon); + } + } + } + + // 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 (locationAddonMap.has(id)) + continue; + let migrateData = id in locMigrateData ? locMigrateData[id] : null; + let newAddon = loadedManifest(installLocation, id); + let addon = this.addMetadata(installLocation, id, xpiState, newAddon, + aOldAppVersion, aOldPlatformVersion, migrateData); + if (addon) + locationAddonMap.set(addon.id, addon); + } + } + } + + // previousAddons may contain locations 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 previousAddons) { + if (!currentAddons.has(locationName)) { + for (let [id, oldAddon] of addons) + this.removeMetadata(oldAddon); + } + } + + // Validate the updated system add-ons + let systemAddonLocation = XPIProvider.installLocationsByName[KEY_APP_SYSTEM_ADDONS]; + let addons = currentAddons.get(KEY_APP_SYSTEM_ADDONS) || new Map(); + + let hideLocation; + + if (!systemAddonLocation.isValid(addons)) { + // Hide the system add-on updates if any are invalid. + logger.info("One or more updated system add-ons invalid, falling back to defaults."); + hideLocation = KEY_APP_SYSTEM_ADDONS; + } + + let previousVisible = this.getVisibleAddons(previousAddons); + let currentVisible = this.flattenByID(currentAddons, hideLocation); + let sawActiveTheme = false; + XPIProvider.bootstrappedAddons = {}; + + // Pass over the new set of visible add-ons, record any changes that occured + // during startup and call bootstrap install/uninstall scripts as necessary + for (let [id, currentAddon] of currentVisible) { + let previousAddon = previousVisible.get(id); + + // Note if any visible add-on is not in the application install location + if (currentAddon._installLocation.name != KEY_APP_GLOBAL) + XPIProvider.allAppGlobal = false; + + let isActive = !currentAddon.disabled; + let wasActive = previousAddon ? previousAddon.active : currentAddon.active + + if (!previousAddon) { + // If we had a manifest for this add-on it was a staged install and + // so wasn't something recovered from a corrupt database + let wasStaged = !!loadedManifest(currentAddon._installLocation, id); + + // We might be recovering from a corrupt database, if so use the + // list of known active add-ons to update the new add-on + if (!wasStaged && XPIDatabase.activeBundles) { + // For themes we know which is active by the current skin setting + if (currentAddon.type == "theme") + isActive = currentAddon.internalName == XPIProvider.currentSkin; + else + isActive = XPIDatabase.activeBundles.indexOf(currentAddon.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 (!isActive && !currentAddon.disabled) { + // If the add-on is softblocked then assume it is softDisabled + if (currentAddon.blocklistState == Blocklist.STATE_SOFTBLOCKED) + currentAddon.softDisabled = true; + else + currentAddon.userDisabled = true; + } + } + else { + // This is a new install + if (currentAddon.foreignInstall) + AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_INSTALLED, id); + + if (currentAddon.bootstrap) { + AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_INSTALLED, id); + // Visible bootstrapped add-ons need to have their install method called + XPIProvider.callBootstrapMethod(currentAddon, currentAddon._sourceBundle, + "install", BOOTSTRAP_REASONS.ADDON_INSTALL); + if (!isActive) + XPIProvider.unloadBootstrapScope(currentAddon.id); + } + } + } + else { + if (previousAddon !== currentAddon) { + // This is an add-on that has changed, either the metadata was reloaded + // or the version in a different location has become visible + AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_CHANGED, id); + + let installReason = Services.vc.compare(previousAddon.version, currentAddon.version) < 0 ? + BOOTSTRAP_REASONS.ADDON_UPGRADE : + BOOTSTRAP_REASONS.ADDON_DOWNGRADE; + + // If the previous add-on was in a different path, bootstrapped + // and still exists then call its uninstall method. + if (previousAddon.bootstrap && previousAddon._installLocation && + exists(previousAddon) && + currentAddon._sourceBundle.path != previousAddon._sourceBundle.path) { + + XPIProvider.callBootstrapMethod(previousAddon, previousAddon._sourceBundle, + "uninstall", installReason, + { newVersion: currentAddon.version }); + XPIProvider.unloadBootstrapScope(previousAddon.id); + } + + // Make sure to flush the cache when an old add-on has gone away + flushChromeCaches(); + + if (currentAddon.bootstrap) { + // Visible bootstrapped add-ons need to have their install method called + let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsIFile); + file.persistentDescriptor = currentAddon._sourceBundle.persistentDescriptor; + XPIProvider.callBootstrapMethod(currentAddon, file, + "install", installReason, + { oldVersion: previousAddon.version }); + if (currentAddon.disabled) + XPIProvider.unloadBootstrapScope(currentAddon.id); + } + } + + if (isActive != wasActive) { + let change = isActive ? AddonManager.STARTUP_CHANGE_ENABLED + : AddonManager.STARTUP_CHANGE_DISABLED; + AddonManagerPrivate.addStartupChange(change, id); + } + } + + XPIDatabase.makeAddonVisible(currentAddon); + currentAddon.active = isActive; + + // Make sure the bootstrap information is up to date for this ID + if (currentAddon.bootstrap && currentAddon.active) { + XPIProvider.bootstrappedAddons[id] = { + version: currentAddon.version, + type: currentAddon.type, + descriptor: currentAddon._sourceBundle.persistentDescriptor, + multiprocessCompatible: currentAddon.multiprocessCompatible, + runInSafeMode: canRunInSafeMode(currentAddon), + dependencies: currentAddon.dependencies, + hasEmbeddedWebExtension: currentAddon.hasEmbeddedWebExtension, + }; + } + + if (currentAddon.active && currentAddon.internalName == XPIProvider.selectedSkin) + sawActiveTheme = true; + } + + // Pass over the set of previously visible add-ons that have now gone away + // and record the change. + for (let [id, previousAddon] of previousVisible) { + if (currentVisible.has(id)) + continue; + + // This add-on vanished + + // If the previous add-on was bootstrapped and still exists then call its + // uninstall method. + if (previousAddon.bootstrap && exists(previousAddon)) { + XPIProvider.callBootstrapMethod(previousAddon, previousAddon._sourceBundle, + "uninstall", BOOTSTRAP_REASONS.ADDON_UNINSTALL); + XPIProvider.unloadBootstrapScope(previousAddon.id); + } + AddonManagerPrivate.addStartupChange(AddonManager.STARTUP_CHANGE_UNINSTALLED, id); + + // Make sure to flush the cache when an old add-on has gone away + flushChromeCaches(); + } + + // Make sure add-ons from hidden locations are marked invisible and inactive + let locationAddonMap = currentAddons.get(hideLocation); + if (locationAddonMap) { + for (let addon of locationAddonMap.values()) { + addon.visible = false; + addon.active = false; + } + } + + // If a custom theme is selected and it wasn't seen in the new list of + // active add-ons then enable the default theme + if (XPIProvider.selectedSkin != XPIProvider.defaultSkin && !sawActiveTheme) { + logger.info("Didn't see selected skin " + XPIProvider.selectedSkin); + XPIProvider.enableDefaultTheme(); + } + + // Finally update XPIStates to match everything + for (let [locationName, locationAddonMap] of currentAddons) { + for (let [id, addon] of locationAddonMap) { + let xpiState = XPIStates.getAddon(locationName, id); + xpiState.syncWithDB(addon); + } + } + XPIStates.save(); + + XPIProvider.persistBootstrappedAddons(); + + // Clear out any cached migration data. + XPIDatabase.migrateData = null; + XPIDatabase.saveChanges(); + + return true; + }, +} diff --git a/toolkit/mozapps/extensions/internal/moz.build b/toolkit/mozapps/extensions/internal/moz.build new file mode 100644 index 0000000000..28c34f8c99 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/moz.build @@ -0,0 +1,36 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +EXTRA_JS_MODULES.addons += [ + 'AddonLogging.jsm', + 'AddonRepository.jsm', + 'AddonRepository_SQLiteMigrator.jsm', + 'AddonUpdateChecker.jsm', + 'APIExtensionBootstrap.js', + 'Content.js', + 'E10SAddonsRollout.jsm', + 'GMPProvider.jsm', + 'LightweightThemeImageOptimizer.jsm', + 'ProductAddonChecker.jsm', + 'SpellCheckDictionaryBootstrap.js', + 'WebExtensionBootstrap.js', + 'XPIProvider.jsm', + 'XPIProviderUtils.js', +] + +TESTING_JS_MODULES += [ + 'AddonTestUtils.jsm', +] + +# Don't ship unused providers on Android +if CONFIG['MOZ_WIDGET_TOOLKIT'] != 'android': + EXTRA_JS_MODULES.addons += [ + 'PluginProvider.jsm', + ] + +EXTRA_PP_JS_MODULES.addons += [ + 'AddonConstants.jsm', +] -- cgit v1.2.3