diff options
Diffstat (limited to '')
| -rw-r--r-- | browser/components/migration/SafariProfileMigrator.sys.mjs | 674 |
1 files changed, 674 insertions, 0 deletions
diff --git a/browser/components/migration/SafariProfileMigrator.sys.mjs b/browser/components/migration/SafariProfileMigrator.sys.mjs new file mode 100644 index 0000000000..4a68178e4b --- /dev/null +++ b/browser/components/migration/SafariProfileMigrator.sys.mjs @@ -0,0 +1,674 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +import { FileUtils } from "resource://gre/modules/FileUtils.sys.mjs"; + +import { MigrationUtils } from "resource:///modules/MigrationUtils.sys.mjs"; +import { MigratorBase } from "resource:///modules/MigratorBase.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + FormHistory: "resource://gre/modules/FormHistory.sys.mjs", + PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", + PropertyListUtils: "resource://gre/modules/PropertyListUtils.sys.mjs", +}); + +// NSDate epoch is Jan 1, 2001 UTC +const NS_DATE_EPOCH_MS = new Date("2001-01-01T00:00:00-00:00").getTime(); + +// Convert NSDate timestamp to UNIX timestamp. +function parseNSDate(cocoaDateStr) { + let asDouble = parseFloat(cocoaDateStr); + if (!isNaN(asDouble)) { + return new Date(NS_DATE_EPOCH_MS + asDouble * 1000); + } + return new Date(); +} + +// Convert UNIX timestamp to NSDate timestamp. +function msToNSDate(ms) { + return parseFloat(ms - NS_DATE_EPOCH_MS) / 1000; +} + +function Bookmarks(aBookmarksFile) { + this._file = aBookmarksFile; +} +Bookmarks.prototype = { + type: MigrationUtils.resourceTypes.BOOKMARKS, + + migrate: function B_migrate(aCallback) { + return (async () => { + let dict = await new Promise(resolve => + lazy.PropertyListUtils.read(this._file, resolve) + ); + if (!dict) { + throw new Error("Could not read Bookmarks.plist"); + } + let children = dict.get("Children"); + if (!children) { + throw new Error("Invalid Bookmarks.plist format"); + } + + let collection = + dict.get("Title") == "com.apple.ReadingList" + ? this.READING_LIST_COLLECTION + : this.ROOT_COLLECTION; + await this._migrateRootCollection(children, collection); + })().then( + () => aCallback(true), + e => { + console.error(e); + aCallback(false); + } + ); + }, + + // Bookmarks collections in Safari. Constants for migrateCollection. + ROOT_COLLECTION: 0, + MENU_COLLECTION: 1, + TOOLBAR_COLLECTION: 2, + READING_LIST_COLLECTION: 3, + + /** + * Start the migration of a Safari collection of bookmarks by retrieving favicon data. + * + * @param {object[]} aEntries + * The collection's children + * @param {number} aCollection + * One of the _COLLECTION values above. + */ + async _migrateRootCollection(aEntries, aCollection) { + // First, try to get the favicon data of a user's bookmarks. + // In Safari, Favicons are stored as files with a unique name: + // the MD5 hash of the UUID of an SQLite entry in favicons.db. + // Thus, we must create a map from bookmark URLs -> their favicon entry's UUID. + let bookmarkURLToUUIDMap = new Map(); + + const faviconFolder = FileUtils.getDir( + "ULibDir", + ["Safari", "Favicon Cache"], + false + ).path; + let dbPath = PathUtils.join(faviconFolder, "favicons.db"); + + try { + // If there is an error getting favicon data, we catch the error and move on. + // In this case, the bookmarkURLToUUIDMap will be left empty. + let rows = await MigrationUtils.getRowsFromDBWithoutLocks( + dbPath, + "Safari favicons", + `SELECT I.uuid, I.url AS favicon_url, P.url + FROM icon_info I + INNER JOIN page_url P ON I.uuid = P.uuid;` + ); + + if (rows) { + // Convert the rows from our SQLite database into a map from bookmark url to uuid + for (let row of rows) { + let uniqueURL = Services.io.newURI(row.getResultByName("url")).spec; + + // Normalize the URL by removing any trailing slashes. We'll make sure to do + // the same when doing look-ups during a migration. + if (uniqueURL.endsWith("/")) { + uniqueURL = uniqueURL.replace(/\/+$/, ""); + } + bookmarkURLToUUIDMap.set(uniqueURL, row.getResultByName("uuid")); + } + } + } catch (ex) { + console.error(ex); + } + + await this._migrateCollection(aEntries, aCollection, bookmarkURLToUUIDMap); + }, + + /** + * Recursively migrate a Safari collection of bookmarks. + * + * @param {object[]} aEntries + * The collection's children + * @param {number} aCollection + * One of the _COLLECTION values above + * @param {Map} bookmarkURLToUUIDMap + * A map from a bookmark's URL to the UUID of its entry in the favicons.db database + * @returns {Promise<undefined>} + * Resolves after the bookmarks and favicons have been inserted into the + * appropriate databases. + */ + async _migrateCollection(aEntries, aCollection, bookmarkURLToUUIDMap) { + // A collection of bookmarks in Safari resembles places roots. In the + // property list files (Bookmarks.plist, ReadingList.plist) they are + // stored as regular bookmarks folders, and thus can only be distinguished + // from by their names and places in the hierarchy. + + let entriesFiltered = []; + if (aCollection == this.ROOT_COLLECTION) { + for (let entry of aEntries) { + let type = entry.get("WebBookmarkType"); + if (type == "WebBookmarkTypeList" && entry.has("Children")) { + let title = entry.get("Title"); + let children = entry.get("Children"); + if (title == "BookmarksBar") { + await this._migrateCollection( + children, + this.TOOLBAR_COLLECTION, + bookmarkURLToUUIDMap + ); + } else if (title == "BookmarksMenu") { + await this._migrateCollection( + children, + this.MENU_COLLECTION, + bookmarkURLToUUIDMap + ); + } else if (title == "com.apple.ReadingList") { + await this._migrateCollection( + children, + this.READING_LIST_COLLECTION, + bookmarkURLToUUIDMap + ); + } else if (entry.get("ShouldOmitFromUI") !== true) { + entriesFiltered.push(entry); + } + } else if (type == "WebBookmarkTypeLeaf") { + entriesFiltered.push(entry); + } + } + } else { + entriesFiltered = aEntries; + } + + if (!entriesFiltered.length) { + return; + } + + let folderGuid = -1; + switch (aCollection) { + case this.ROOT_COLLECTION: { + // In Safari, it is possible (though quite cumbersome) to move + // bookmarks to the bookmarks root, which is the parent folder of + // all bookmarks "collections". That is somewhat in parallel with + // both the places root and the unfiled-bookmarks root. + // Because the former is only an implementation detail in our UI, + // the unfiled root seems to be the best choice. + folderGuid = lazy.PlacesUtils.bookmarks.unfiledGuid; + break; + } + case this.MENU_COLLECTION: { + folderGuid = lazy.PlacesUtils.bookmarks.menuGuid; + break; + } + case this.TOOLBAR_COLLECTION: { + folderGuid = lazy.PlacesUtils.bookmarks.toolbarGuid; + break; + } + case this.READING_LIST_COLLECTION: { + // Reading list items are imported as regular bookmarks. + // They are imported under their own folder, created either under the + // bookmarks menu (in the case of startup migration). + let readingListTitle = await MigrationUtils.getLocalizedString( + "imported-safari-reading-list" + ); + folderGuid = ( + await MigrationUtils.insertBookmarkWrapper({ + parentGuid: lazy.PlacesUtils.bookmarks.menuGuid, + type: lazy.PlacesUtils.bookmarks.TYPE_FOLDER, + title: readingListTitle, + }) + ).guid; + break; + } + default: + throw new Error("Unexpected value for aCollection!"); + } + if (folderGuid == -1) { + throw new Error("Invalid folder GUID"); + } + + await this._migrateEntries( + entriesFiltered, + folderGuid, + bookmarkURLToUUIDMap + ); + }, + + /** + * Migrates bookmarks and favicons from Safari to Firefox. + * + * @param {object[]} entries + * The Safari collection's children + * @param {number} parentGuid + * GUID of the collection folder + * @param {Map} bookmarkURLToUUIDMap + * A map from a bookmark's URL to the UUID of its entry in the favicons.db database + */ + async _migrateEntries(entries, parentGuid, bookmarkURLToUUIDMap) { + let { convertedEntries, favicons } = await this._convertEntries( + entries, + bookmarkURLToUUIDMap + ); + + await MigrationUtils.insertManyBookmarksWrapper( + convertedEntries, + parentGuid + ); + + MigrationUtils.insertManyFavicons(favicons); + }, + + /** + * Converts Safari collection entries into a suitable format for + * inserting bookmarks and favicons. + * + * @param {object[]} entries + * The collection's children + * @param {Map} bookmarkURLToUUIDMap + * A map from a bookmark's URL to the UUID of its entry in the favicons.db database + * @returns {object[]} + * Returns an object with an array of converted bookmark entries and favicons + */ + async _convertEntries(entries, bookmarkURLToUUIDMap) { + let favicons = []; + let convertedEntries = []; + + const faviconFolder = FileUtils.getDir( + "ULibDir", + ["Safari", "Favicon Cache"], + false + ).path; + + for (const entry of entries) { + let type = entry.get("WebBookmarkType"); + if (type == "WebBookmarkTypeList" && entry.has("Children")) { + let convertedChildren = await this._convertEntries( + entry.get("Children"), + bookmarkURLToUUIDMap + ); + favicons.push(...convertedChildren.favicons); + convertedEntries.push({ + title: entry.get("Title"), + type: lazy.PlacesUtils.bookmarks.TYPE_FOLDER, + children: convertedChildren.convertedEntries, + }); + } else if (type == "WebBookmarkTypeLeaf" && entry.has("URLString")) { + // Check we understand this URL before adding it: + let url = entry.get("URLString"); + try { + new URL(url); + } catch (ex) { + console.error( + `Ignoring ${url} when importing from Safari because of exception: ${ex}` + ); + continue; + } + let title; + if (entry.has("URIDictionary")) { + title = entry.get("URIDictionary").get("title"); + } + convertedEntries.push({ url, title }); + + try { + // Try to get the favicon data for each bookmark we have. + // We use uri.spec as our unique identifier since bookmark links + // don't completely match up in the Safari data. + let uri = Services.io.newURI(url); + let uriSpec = uri.spec; + + // Safari's favicon database doesn't include forward slashes for + // the page URLs, despite adding them in the Bookmarks.plist file. + // We'll strip any off here for our favicon lookup. + if (uriSpec.endsWith("/")) { + uriSpec = uriSpec.replace(/\/+$/, ""); + } + + let uuid = bookmarkURLToUUIDMap.get(uriSpec); + if (uuid) { + // Hash the UUID with md5 to give us the favicon file name. + let hashedUUID = lazy.PlacesUtils.md5(uuid, { + format: "hex", + }).toUpperCase(); + let faviconFile = PathUtils.join( + faviconFolder, + "favicons", + hashedUUID + ); + let faviconData = await IOUtils.read(faviconFile); + favicons.push({ faviconData, uri }); + } + } catch (error) { + // Even if we fail, still continue the import process + // since favicons aren't as essential as the bookmarks themselves. + console.error(error); + } + } + } + + return { convertedEntries, favicons }; + }, +}; + +async function GetHistoryResource() { + let dbPath = FileUtils.getDir( + "ULibDir", + ["Safari", "History.db"], + false + ).path; + let maxAge = msToNSDate( + Date.now() - MigrationUtils.HISTORY_MAX_AGE_IN_MILLISECONDS + ); + + // If we have read access to the Safari profile directory, check to + // see if there's any history to import. If we can't access the profile + // directory, let's assume that there's history to import and give the + // user the option to migrate it. + let canReadHistory = false; + try { + // 'stat' is always allowed, but reading is somehow not, if the user hasn't + // allowed it: + await IOUtils.read(dbPath, { maxBytes: 1 }); + canReadHistory = true; + } catch (ex) { + console.error( + "Cannot yet read from Safari profile directory. Will presume history exists for import." + ); + } + + if (canReadHistory) { + let countQuery = ` + SELECT COUNT(*) + FROM history_items LEFT JOIN history_visits + ON history_items.id = history_visits.history_item + WHERE history_visits.visit_time > ${maxAge} + LIMIT 1;`; + + let countResult = await MigrationUtils.getRowsFromDBWithoutLocks( + dbPath, + "Safari history", + countQuery + ); + + if (!countResult[0].getResultByName("COUNT(*)")) { + return null; + } + } + + let selectQuery = ` + SELECT + history_items.url as history_url, + history_visits.title as history_title, + history_visits.visit_time as history_time + FROM history_items LEFT JOIN history_visits + ON history_items.id = history_visits.history_item + WHERE history_visits.visit_time > ${maxAge};`; + + return { + type: MigrationUtils.resourceTypes.HISTORY, + + async migrate(callback) { + callback(await this._migrate()); + }, + + async _migrate() { + let historyRows; + + try { + historyRows = await MigrationUtils.getRowsFromDBWithoutLocks( + dbPath, + "Safari history", + selectQuery + ); + + if (!historyRows.length) { + console.log("No history found"); + return false; + } + } catch (ex) { + console.error(ex); + return false; + } + + let pageInfos = []; + for (let row of historyRows) { + pageInfos.push({ + title: row.getResultByName("history_title"), + url: new URL(row.getResultByName("history_url")), + visits: [ + { + transition: lazy.PlacesUtils.history.TRANSITIONS.TYPED, + date: parseNSDate(row.getResultByName("history_time")), + }, + ], + }); + } + await MigrationUtils.insertVisitsWrapper(pageInfos); + + return true; + }, + }; +} + +/** + * Safari's preferences property list is independently used for three purposes: + * (a) importation of preferences + * (b) importation of search strings + * (c) retrieving the home page. + * + * So, rather than reading it three times, it's cached and managed here. + * + * @param {nsIFile} aPreferencesFile + * The .plist file to be read. + */ +function MainPreferencesPropertyList(aPreferencesFile) { + this._file = aPreferencesFile; + this._callbacks = []; +} +MainPreferencesPropertyList.prototype = { + /** + * @see PropertyListUtils.read + * @param {Function} aCallback + * A callback called with an Object representing the key-value pairs + * read out of the .plist file. + */ + read: function MPPL_read(aCallback) { + if ("_dict" in this) { + aCallback(this._dict); + return; + } + + let alreadyReading = !!this._callbacks.length; + this._callbacks.push(aCallback); + if (!alreadyReading) { + lazy.PropertyListUtils.read(this._file, aDict => { + this._dict = aDict; + for (let callback of this._callbacks) { + try { + callback(aDict); + } catch (ex) { + console.error(ex); + } + } + this._callbacks.splice(0); + }); + } + }, +}; + +function SearchStrings(aMainPreferencesPropertyListInstance) { + this._mainPreferencesPropertyList = aMainPreferencesPropertyListInstance; +} +SearchStrings.prototype = { + type: MigrationUtils.resourceTypes.OTHERDATA, + + migrate: function SS_migrate(aCallback) { + this._mainPreferencesPropertyList.read( + MigrationUtils.wrapMigrateFunction(function migrateSearchStrings(aDict) { + if (!aDict) { + throw new Error("Could not get preferences dictionary"); + } + + if (aDict.has("RecentSearchStrings")) { + let recentSearchStrings = aDict.get("RecentSearchStrings"); + if (recentSearchStrings && recentSearchStrings.length) { + let changes = recentSearchStrings.map(searchString => ({ + op: "add", + fieldname: "searchbar-history", + value: searchString, + })); + lazy.FormHistory.update(changes); + } + } + }, aCallback) + ); + }, +}; + +/** + * Safari migrator + */ +export class SafariProfileMigrator extends MigratorBase { + static get key() { + return "safari"; + } + + static get displayNameL10nID() { + return "migration-wizard-migrator-display-name-safari"; + } + + static get brandImage() { + return "chrome://browser/content/migration/brands/safari.png"; + } + + async getResources() { + let profileDir = FileUtils.getDir("ULibDir", ["Safari"], false); + if (!profileDir.exists()) { + return null; + } + + let resources = []; + let pushProfileFileResource = function (aFileName, aConstructor) { + let file = profileDir.clone(); + file.append(aFileName); + if (file.exists()) { + resources.push(new aConstructor(file)); + } + }; + + pushProfileFileResource("Bookmarks.plist", Bookmarks); + + // The Reading List feature was introduced at the same time in Windows and + // Mac versions of Safari. Not surprisingly, they are stored in the same + // format in both versions. Surpsingly, only on Windows there is a + // separate property list for it. This code is used on mac too, because + // Apple may fix this at some point. + pushProfileFileResource("ReadingList.plist", Bookmarks); + + let prefs = this.mainPreferencesPropertyList; + if (prefs) { + resources.push(new SearchStrings(prefs)); + } + + resources.push(GetHistoryResource()); + + resources = await Promise.all(resources); + + return resources.filter(r => r != null); + } + + async getLastUsedDate() { + const profileDir = FileUtils.getDir("ULibDir", ["Safari"], false); + const dates = await Promise.all( + ["Bookmarks.plist", "History.db"].map(file => { + const path = PathUtils.join(profileDir.path, file); + return IOUtils.stat(path) + .then(info => info.lastModified) + .catch(() => 0); + }) + ); + + return new Date(Math.max(...dates)); + } + + async hasPermissions() { + if (this._hasPermissions) { + return true; + } + // Check if we have access to some key files, but only if they exist. + let historyTarget = FileUtils.getDir( + "ULibDir", + ["Safari", "History.db"], + false + ); + let bookmarkTarget = FileUtils.getDir( + "ULibDir", + ["Safari", "Bookmarks.plist"], + false + ); + let faviconTarget = FileUtils.getDir( + "ULibDir", + ["Safari", "Favicon Cache", "favicons.db"], + false + ); + try { + let historyExists = await IOUtils.exists(historyTarget.path); + let bookmarksExists = await IOUtils.exists(bookmarkTarget.path); + let faviconsExists = await IOUtils.exists(faviconTarget.path); + // We now know which files exist, which is always allowed. + // To determine if we have read permissions, try to read a single byte + // from each file that exists, which will throw if we need permissions. + if (historyExists) { + await IOUtils.read(historyTarget.path, { maxBytes: 1 }); + } + if (bookmarksExists) { + await IOUtils.read(bookmarkTarget.path, { maxBytes: 1 }); + } + if (faviconsExists) { + await IOUtils.read(faviconTarget.path, { maxBytes: 1 }); + } + this._hasPermissions = true; + return true; + } catch (ex) { + return false; + } + } + + async getPermissions(win) { + // Keep prompting the user until they pick something that grants us access + // to Safari's bookmarks and favicons or they cancel out of the file open panel. + while (!(await this.hasPermissions())) { + let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker); + // The title (second arg) is not displayed on macOS, so leave it blank. + fp.init(win, "", Ci.nsIFilePicker.modeGetFolder); + fp.filterIndex = 1; + fp.displayDirectory = FileUtils.getDir("ULibDir", [""], false); + // Now wait for the filepicker to open and close. If the user picks + // the Safari folder, macOS will grant us read access to everything + // inside, so we don't need to check or do anything else with what's + // returned by the filepicker. + let result = await new Promise(resolve => fp.open(resolve)); + // Bail if the user cancels the dialog: + if (result == Ci.nsIFilePicker.returnCancel) { + return false; + } + } + return true; + } + + get mainPreferencesPropertyList() { + if (this._mainPreferencesPropertyList === undefined) { + let file = FileUtils.getDir("UsrPrfs", [], false); + if (file.exists()) { + file.append("com.apple.Safari.plist"); + if (file.exists()) { + this._mainPreferencesPropertyList = new MainPreferencesPropertyList( + file + ); + return this._mainPreferencesPropertyList; + } + } + this._mainPreferencesPropertyList = null; + return this._mainPreferencesPropertyList; + } + return this._mainPreferencesPropertyList; + } +} |