The Tor Browser: comparison toolkit/modules/ZipUtils.jsm

--1:000000000000
+:1829764c3ba1
+/* 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/. */
+this.EXPORTED_SYMBOLS = [ "ZipUtils" ];
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const Cu = Components.utils;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "FileUtils",
+"resource://gre/modules/FileUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "OS",
+"resource://gre/modules/osfile.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Promise",
+"resource://gre/modules/Promise.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Task",
+"resource://gre/modules/Task.jsm");
+// The maximum amount of file data to buffer at a time during file extraction
+const EXTRACTION_BUFFER               = 1024 * 512;
+/**
+* Asynchronously writes data from an nsIInputStream to an OS.File instance.
+* The source stream and OS.File are closed regardless of whether the operation
+* succeeds or fails.
+* Returns a promise that will be resolved when complete.
+*
+* @param  aPath
+*         The name of the file being extracted for logging purposes.
+* @param  aStream
+*         The source nsIInputStream.
+* @param  aFile
+*         The open OS.File instance to write to.
+*/
+function saveStreamAsync(aPath, aStream, aFile) {
+let deferred = Promise.defer();
+// Read the input stream on a background thread
+let sts = Cc["@mozilla.org/network/stream-transport-service;1"].
+getService(Ci.nsIStreamTransportService);
+let transport = sts.createInputTransport(aStream, -1, -1, true);
+let input = transport.openInputStream(0, 0, 0)
+.QueryInterface(Ci.nsIAsyncInputStream);
+let source = Cc["@mozilla.org/binaryinputstream;1"].
+createInstance(Ci.nsIBinaryInputStream);
+source.setInputStream(input);
+let data = new Uint8Array(EXTRACTION_BUFFER);
+function readFailed(error) {
+try {
+aStream.close();
+}
+catch (e) {
+logger.error("Failed to close JAR stream for " + aPath);
+}
+aFile.close().then(function() {
+deferred.reject(error);
+}, function(e) {
+logger.error("Failed to close file for " + aPath);
+deferred.reject(error);
+});
+}
+function readData() {
+try {
+let count = Math.min(source.available(), data.byteLength);
+source.readArrayBuffer(count, data.buffer);
+aFile.write(data, { bytes: count }).then(function() {
+input.asyncWait(readData, 0, 0, Services.tm.currentThread);
+}, readFailed);
+}
+catch (e if e.result == Cr.NS_BASE_STREAM_CLOSED) {
+deferred.resolve(aFile.close());
+}
+catch (e) {
+readFailed(e);
+}
+}
+input.asyncWait(readData, 0, 0, Services.tm.currentThread);
+return deferred.promise;
+}
+this.ZipUtils = {
+/**
+* Asynchronously extracts files from a ZIP file into a directory.
+* Returns a promise that will be resolved when the extraction is complete.
+*
+* @param  aZipFile
+*         The source ZIP file that contains the add-on.
+* @param  aDir
+*         The nsIFile to extract to.
+*/
+extractFilesAsync: function ZipUtils_extractFilesAsync(aZipFile, aDir) {
+let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
+createInstance(Ci.nsIZipReader);
+try {
+zipReader.open(aZipFile);
+}
+catch (e) {
+return Promise.reject(e);
+}
+return Task.spawn(function() {
+// Get all of the entries in the zip and sort them so we create directories
+// before files
+let entries = zipReader.findEntries(null);
+let names = [];
+while (entries.hasMore())
+names.push(entries.getNext());
+names.sort();
+for (let name of names) {
+let entryName = name;
+let zipentry = zipReader.getEntry(name);
+let path = OS.Path.join(aDir.path, ...name.split("/"));
+if (zipentry.isDirectory) {
+try {
+yield OS.File.makeDir(path);
+}
+catch (e) {
+dump("extractFilesAsync: failed to create directory " + path + "\n");
+throw e;
+}
+}
+else {
+let options = { unixMode: zipentry.permissions | FileUtils.PERMS_FILE };
+try {
+let file = yield OS.File.open(path, { truncate: true }, options);
+if (zipentry.realSize == 0)
+yield file.close();
+else
+yield saveStreamAsync(path, zipReader.getInputStream(entryName), file);
+}
+catch (e) {
+dump("extractFilesAsync: failed to extract file " + path + "\n");
+throw e;
+}
+}
+}
+zipReader.close();
+}).then(null, (e) => {
+zipReader.close();
+throw e;
+});
+},
+/**
+* Extracts files from a ZIP file into a directory.
+*
+* @param  aZipFile
+*         The source ZIP file that contains the add-on.
+* @param  aDir
+*         The nsIFile to extract to.
+*/
+extractFiles: function ZipUtils_extractFiles(aZipFile, aDir) {
+function getTargetFile(aDir, entry) {
+let target = aDir.clone();
+entry.split("/").forEach(function(aPart) {
+target.append(aPart);
+});
+return target;
+}
+let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
+createInstance(Ci.nsIZipReader);
+zipReader.open(aZipFile);
+try {
+// create directories first
+let entries = zipReader.findEntries("*/");
+while (entries.hasMore()) {
+let entryName = entries.getNext();
+let target = getTargetFile(aDir, entryName);
+if (!target.exists()) {
+try {
+target.create(Ci.nsIFile.DIRECTORY_TYPE,
+FileUtils.PERMS_DIRECTORY);
+}
+catch (e) {
+dump("extractFiles: failed to create target directory for extraction file = " + target.path + "\n");
+}
+}
+}
+entries = zipReader.findEntries(null);
+while (entries.hasMore()) {
+let entryName = entries.getNext();
+let target = getTargetFile(aDir, entryName);
+if (target.exists())
+continue;
+zipReader.extract(entryName, target);
+try {
+target.permissions |= FileUtils.PERMS_FILE;
+}
+catch (e) {
+dump("Failed to set permissions " + aPermissions.toString(8) + " on " + target.path + "\n");
+}
+}
+}
+finally {
+zipReader.close();
+}
+}
+};

The Tor Browser / file comparison

comparison: toolkit/modules/ZipUtils.jsm

toolkit/modules/ZipUtils.jsm