core, frontend: Better progress reporter

A new "quick" decryptor is implemented. This is not really much faster (not slower either) but provides the benefit of being able to report progress on a single file. The frontend is updated accordingly to support this feature.

src/common/CMakeLists.txt

@@ -13,6 +13,7 @@ add_library(common STATIC
   string_util.cpp
   string_util.h
   swap.h
+  thread.h
 )
 
 target_link_libraries(common PUBLIC fmt)

src/common/thread.h

@@ -0,0 +1,95 @@
+// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
+//           2019 threeSD Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <chrono>
+#include <condition_variable>
+#include <cstddef>
+#include <mutex>
+#include <thread>
+
+namespace Common {
+
+class Event {
+public:
+    void Set() {
+        std::lock_guard lk{mutex};
+        if (!is_set) {
+            is_set = true;
+            condvar.notify_one();
+        }
+    }
+
+    void Wait() {
+        std::unique_lock lk{mutex};
+        condvar.wait(lk, [&] { return is_set; });
+        is_set = false;
+    }
+
+    template <class Duration>
+    bool WaitFor(const std::chrono::duration<Duration>& time) {
+        std::unique_lock lk(mutex);
+        if (!condvar.wait_for(lk, time, [this] { return is_set; }))
+            return false;
+        is_set = false;
+        return true;
+    }
+
+    template <class Clock, class Duration>
+    bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
+        std::unique_lock lk{mutex};
+        if (!condvar.wait_until(lk, time, [this] { return is_set; }))
+            return false;
+        is_set = false;
+        return true;
+    }
+
+    void Reset() {
+        std::unique_lock lk{mutex};
+        // no other action required, since wait loops on the predicate and any lingering signal will
+        // get cleared on the first iteration
+        is_set = false;
+    }
+
+private:
+    bool is_set = false;
+    std::condition_variable condvar;
+    std::mutex mutex;
+};
+
+class Barrier {
+public:
+    explicit Barrier(std::size_t count_) : count(count_) {}
+
+    /// Blocks until all "count" threads have called Sync()
+    void Sync() {
+        std::unique_lock lk{mutex};
+        const std::size_t current_generation = generation;
+
+        if (++waiting == count) {
+            generation++;
+            waiting = 0;
+            condvar.notify_all();
+        } else {
+            condvar.wait(lk,
+                         [this, current_generation] { return current_generation != generation; });
+        }
+    }
+
+    std::size_t Generation() const {
+        std::unique_lock lk(mutex);
+        return generation;
+    }
+
+private:
+    std::condition_variable condvar;
+    mutable std::mutex mutex;
+    std::size_t count;
+    std::size_t waiting = 0;
+    std::size_t generation = 0; // Incremented once each time the barrier is used
+};
+
+} // namespace Common

src/core/CMakeLists.txt

@@ -11,6 +11,8 @@ add_library(core STATIC
   key/arithmetic128.h
   key/key.cpp
   key/key.h
+  quick_decryptor.cpp
+  quick_decryptor.h
 )
 
 target_link_libraries(core PRIVATE common cryptopp)

src/core/decryptor.cpp

@@ -17,7 +17,9 @@
 
 namespace Core {
 
-SDMCDecryptor::SDMCDecryptor(const std::string& root_folder_) : root_folder(root_folder_) {
+SDMCDecryptor::SDMCDecryptor(const std::string& root_folder_)
+    : root_folder(root_folder_), quick_decryptor(root_folder) {
+
     ASSERT_MSG(Key::IsNormalKeyAvailable(Key::SDKey),
                "SD Key must be available in order to decrypt");
 
@@ -47,28 +49,13 @@ std::array<u8, 16> GetFileCTR(const std::string& path) {
 }
 } // namespace
 
-bool SDMCDecryptor::DecryptAndWriteFile(const std::string& source,
-                                        const std::string& destination) const {
-    auto ctr = GetFileCTR(source);
-    auto key = Key::GetNormalKey(Key::SDKey);
-    CryptoPP::CTR_Mode<CryptoPP::AES>::Decryption aes;
-    aes.SetKeyWithIV(key.data(), key.size(), ctr.data());
+bool SDMCDecryptor::DecryptAndWriteFile(const std::string& source, const std::string& destination,
+                                        const QuickDecryptor::ProgressCallback& callback) {
+    return quick_decryptor.DecryptAndWriteFile(source, destination, callback);
+}
 
-    if (!FileUtil::CreateFullPath(destination)) {
-        return false;
-    }
-
-    std::string absolute_source = root_folder + source;
-    try {
-        CryptoPP::FileSource(absolute_source.c_str(), true,
-                             new CryptoPP::StreamTransformationFilter(
-                                 aes, new CryptoPP::FileSink(destination.c_str(), true)),
-                             true);
-    } catch (CryptoPP::Exception& e) {
-        LOG_ERROR(Core, "Error decrypting and writing file: {}", e.what());
-        return false;
-    }
-    return true;
+void SDMCDecryptor::Abort() {
+    quick_decryptor.Abort();
 }
 
 std::vector<u8> SDMCDecryptor::DecryptFile(const std::string& source) const {

src/core/decryptor.h

@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 #include "common/common_types.h"
+#include "core/quick_decryptor.h"
 
 namespace Core {
 
@@ -22,11 +23,17 @@ public:
 
     /**
      * Decrypts a file from the SD card and writes it into another file.
+     * This function blocks, but can be aborted with the Abort() function (would return false)
+     *
      * @param source Path to the file relative to the root folder, starting with "/".
      * @param destination Path to the destination file.
      * @return true on success, false otherwise
      */
-    bool DecryptAndWriteFile(const std::string& source, const std::string& destination) const;
+    bool DecryptAndWriteFile(const std::string& source, const std::string& destination,
+                             const QuickDecryptor::ProgressCallback& callback = [](std::size_t,
+                                                                                   std::size_t) {});
+
+    void Abort();
 
     /**
      * Decrypts a file and reads it into a vector.
@@ -36,6 +43,7 @@ public:
 
 private:
     std::string root_folder;
+    QuickDecryptor quick_decryptor;
 };
 
 } // namespace Core

src/core/importer.cpp

@@ -53,29 +53,34 @@ bool SDMCImporter::IsGood() const {
     return is_good;
 }
 
-bool SDMCImporter::ImportContent(const ContentSpecifier& specifier) {
+void SDMCImporter::Abort() {
+    decryptor->Abort();
+}
+
+bool SDMCImporter::ImportContent(const ContentSpecifier& specifier,
+                                 const ProgressCallback& callback) {
     switch (specifier.type) {
     case ContentType::Application:
     case ContentType::Update:
     case ContentType::DLC:
-        return ImportTitle(specifier.id);
+        return ImportTitle(specifier.id, callback);
     case ContentType::Savegame:
-        return ImportSavegame(specifier.id);
+        return ImportSavegame(specifier.id, callback);
     case ContentType::Extdata:
-        return ImportExtdata(specifier.id);
+        return ImportExtdata(specifier.id, callback);
     case ContentType::Sysdata:
-        return ImportSysdata(specifier.id);
+        return ImportSysdata(specifier.id, callback);
     default:
         UNREACHABLE();
     }
 }
 
-bool SDMCImporter::ImportTitle(u64 id) {
+bool SDMCImporter::ImportTitle(u64 id, const ProgressCallback& callback) {
     const auto path = fmt::format("title/{:08x}/{:08x}/content/", (id >> 32), (id & 0xFFFFFFFF));
     return FileUtil::ForeachDirectoryEntry(
         nullptr, config.sdmc_path + path,
-        [this, &path](u64* /*num_entries_out*/, const std::string& directory,
-                      const std::string& virtual_name) {
+        [this, &path, callback](u64* /*num_entries_out*/, const std::string& directory,
+                                const std::string& virtual_name) {
             if (FileUtil::IsDirectory(directory + virtual_name)) {
                 return true;
             }
@@ -84,11 +89,12 @@ bool SDMCImporter::ImportTitle(u64 id) {
                 FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir) +
                     "Nintendo "
                     "3DS/00000000000000000000000000000000/00000000000000000000000000000000/" +
-                    path + virtual_name);
+                    path + virtual_name,
+                callback);
         });
 }
 
-bool SDMCImporter::ImportSavegame(u64 id) {
+bool SDMCImporter::ImportSavegame(u64 id, [[maybe_unused]] const ProgressCallback& callback) {
     const auto path = fmt::format("title/{:08x}/{:08x}/data/", (id >> 32), (id & 0xFFFFFFFF));
 
     DataContainer container(decryptor->DecryptFile(fmt::format("/{}00000001.sav", path)));
@@ -106,7 +112,7 @@ bool SDMCImporter::ImportSavegame(u64 id) {
         "Nintendo 3DS/00000000000000000000000000000000/00000000000000000000000000000000/" + path);
 }
 
-bool SDMCImporter::ImportExtdata(u64 id) {
+bool SDMCImporter::ImportExtdata(u64 id, [[maybe_unused]] const ProgressCallback& callback) {
     const auto path = fmt::format("extdata/{:08x}/{:08x}/", (id >> 32), (id & 0xFFFFFFFF));
     SDExtdata extdata("/" + path, *decryptor);
     if (!extdata.IsGood()) {
@@ -118,7 +124,7 @@ bool SDMCImporter::ImportExtdata(u64 id) {
         "Nintendo 3DS/00000000000000000000000000000000/00000000000000000000000000000000/" + path);
 }
 
-bool SDMCImporter::ImportSysdata(u64 id) {
+bool SDMCImporter::ImportSysdata(u64 id, [[maybe_unused]] const ProgressCallback& callback) {
     switch (id) {
     case 0: { // boot9.bin
         const auto target_path = FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + BOOTROM9;
@@ -330,6 +336,74 @@ void SDMCImporter::ListSysdata(std::vector<ContentSpecifier>& out) const {
     } while (0);
 }
 
+void SDMCImporter::DeleteContent(const ContentSpecifier& specifier) {
+    switch (specifier.type) {
+    case ContentType::Application:
+    case ContentType::Update:
+    case ContentType::DLC:
+        return DeleteTitle(specifier.id);
+    case ContentType::Savegame:
+        return DeleteSavegame(specifier.id);
+    case ContentType::Extdata:
+        return DeleteExtdata(specifier.id);
+    case ContentType::Sysdata:
+        return DeleteSysdata(specifier.id);
+    default:
+        UNREACHABLE();
+    }
+}
+
+void SDMCImporter::DeleteTitle(u64 id) const {
+    FileUtil::DeleteDirRecursively(fmt::format(
+        "{}Nintendo "
+        "3DS/00000000000000000000000000000000/00000000000000000000000000000000/title/{:08x}/{:08x}/"
+        "content/",
+        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir), (id >> 32), (id & 0xFFFFFFFF)));
+}
+
+void SDMCImporter::DeleteSavegame(u64 id) const {
+    FileUtil::DeleteDirRecursively(fmt::format(
+        "{}Nintendo "
+        "3DS/00000000000000000000000000000000/00000000000000000000000000000000/title/{:08x}/{:08x}/"
+        "data/",
+        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir), (id >> 32), (id & 0xFFFFFFFF)));
+}
+
+void SDMCImporter::DeleteExtdata(u64 id) const {
+    FileUtil::DeleteDirRecursively(fmt::format(
+        "{}Nintendo "
+        "3DS/00000000000000000000000000000000/00000000000000000000000000000000/extdata/{:08x}/"
+        "{:08x}/",
+        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir), (id >> 32), (id & 0xFFFFFFFF)));
+}
+
+void SDMCImporter::DeleteSysdata(u64 id) const {
+    switch (id) {
+    case 0: { // boot9.bin
+        FileUtil::Delete(FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + BOOTROM9);
+    }
+    case 1: { // safe mode firm
+        const bool is_new_3ds = FileUtil::Exists(config.safe_mode_firm_path + "new/");
+        const auto target_path =
+            fmt::format("{}00000000000000000000000000000000/title/00040138/{}/",
+                        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir),
+                        (is_new_3ds ? "20000003" : "00000003"));
+        FileUtil::DeleteDirRecursively(target_path);
+    }
+    case 2: { // seed db
+        FileUtil::Delete(FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + SEED_DB);
+    }
+    case 3: { // secret sector
+        FileUtil::Delete(FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + SECRET_SECTOR);
+    }
+    case 4: { // aes_keys.txt
+        FileUtil::Delete(FileUtil::GetUserPath(FileUtil::UserPath::SysDataDir) + AES_KEYS);
+    }
+    default:
+        UNREACHABLE_MSG("Unexpected sysdata id {}", id);
+    }
+}
+
 std::vector<Config> LoadPresetConfig(std::string mount_point) {
     if (mount_point.back() != '/' && mount_point.back() != '\\') {
         mount_point += '/';

src/core/importer.h

@@ -61,6 +61,9 @@ struct Config {
 
 class SDMCImporter {
 public:
+    /// (current_size, total_size)
+    using ProgressCallback = std::function<void(std::size_t, std::size_t)>;
+
     /**
      * Initializes the importer.
      * @param root_folder Path to the "Nintendo 3DS/<ID0>/<ID1>" folder.
@@ -70,10 +73,23 @@ public:
     ~SDMCImporter();
 
     /**
-     * Dumps a specific content by its specifier.
+     * Aborts a specific content by its specifier.
+     * Blocks, but can be aborted on another thread if needed.
      * @return true on success, false otherwise
      */
-    bool ImportContent(const ContentSpecifier& specifier);
+    bool ImportContent(const ContentSpecifier& specifier,
+                       const ProgressCallback& callback = [](std::size_t, std::size_t) {});
+
+    /**
+     * Deletes/Cleans up a content. Used for deleting contents that have
+     * not been fully imported.
+     */
+    void DeleteContent(const ContentSpecifier& specifier);
+
+    /**
+     * Aborts current importing.
+     */
+    void Abort();
 
     /**
      * Gets a list of dumpable content specifiers.
@@ -87,13 +103,17 @@ public:
 
 private:
     bool Init();
-    bool ImportTitle(u64 id);
-    bool ImportSavegame(u64 id);
-    bool ImportExtdata(u64 id);
-    bool ImportSysdata(u64 id);
+    bool ImportTitle(u64 id, const ProgressCallback& callback);
+    bool ImportSavegame(u64 id, const ProgressCallback& callback);
+    bool ImportExtdata(u64 id, const ProgressCallback& callback);
+    bool ImportSysdata(u64 id, const ProgressCallback& callback);
     void ListTitle(std::vector<ContentSpecifier>& out) const;
     void ListExtdata(std::vector<ContentSpecifier>& out) const;
     void ListSysdata(std::vector<ContentSpecifier>& out) const;
+    void DeleteTitle(u64 id) const;
+    void DeleteSavegame(u64 id) const;
+    void DeleteExtdata(u64 id) const;
+    void DeleteSysdata(u64 id) const;
 
     bool is_good{};
     Config config;

src/core/quick_decryptor.cpp

@@ -0,0 +1,204 @@
+// Copyright 2019 threeSD Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <vector>
+#include <cryptopp/aes.h>
+#include <cryptopp/files.h>
+#include <cryptopp/filters.h>
+#include <cryptopp/modes.h>
+#include <cryptopp/sha.h>
+#include "common/assert.h"
+#include "common/file_util.h"
+#include "common/string_util.h"
+#include "core/key/key.h"
+#include "core/quick_decryptor.h"
+
+namespace Core {
+
+QuickDecryptor::QuickDecryptor(const std::string& root_folder_) : root_folder(root_folder_) {
+    ASSERT_MSG(Key::IsNormalKeyAvailable(Key::SDKey),
+               "SD Key must be available in order to decrypt");
+
+    if (root_folder.back() == '/' || root_folder.back() == '\\') {
+        // Remove '/' or '\' character at the end as we will add them back when combining path
+        root_folder.erase(root_folder.size() - 1);
+    }
+}
+
+QuickDecryptor::~QuickDecryptor() = default;
+
+namespace {
+std::array<u8, 16> GetFileCTR(const std::string& path) {
+    auto path_utf16 = Common::UTF8ToUTF16(path);
+    std::vector<u8> path_data(path_utf16.size() * 2 + 2, 0); // Add the '\0' character
+    std::memcpy(path_data.data(), path_utf16.data(), path_utf16.size() * 2);
+
+    CryptoPP::SHA256 sha;
+    std::array<u8, CryptoPP::SHA256::DIGESTSIZE> hash;
+    sha.CalculateDigest(hash.data(), path_data.data(), path_data.size());
+
+    std::array<u8, 16> ctr;
+    for (int i = 0; i < 16; i++) {
+        ctr[i] = hash[i] ^ hash[16 + i];
+    }
+    return ctr;
+}
+} // namespace
+
+bool QuickDecryptor::DecryptAndWriteFile(const std::string& source_,
+                                         const std::string& destination_,
+                                         const ProgressCallback& callback_) {
+    if (is_running) {
+        LOG_ERROR(Core, "Decryptor is running");
+        return false;
+    }
+
+    if (!FileUtil::CreateFullPath(destination_)) {
+        LOG_ERROR(Core, "Could not create path {}", destination_);
+        return false;
+    }
+
+    for (auto& event : data_read_event) {
+        event.Reset();
+    }
+    for (auto& event : data_decrypted_event) {
+        event.Reset();
+    }
+    for (auto& event : data_written_event) {
+        event.Reset();
+    }
+    completion_event.Reset();
+
+    source = source_;
+    destination = destination_;
+    callback = callback_;
+
+    total_size = FileUtil::GetSize(root_folder + source);
+    if (total_size == 0) {
+        LOG_ERROR(Core, "Could not open file {}", root_folder + source);
+        return false;
+    }
+
+    is_good = is_running = true;
+
+    read_thread = std::make_unique<std::thread>(&QuickDecryptor::DataReadLoop, this);
+    decrypt_thread = std::make_unique<std::thread>(&QuickDecryptor::DataDecryptLoop, this);
+    write_thread = std::make_unique<std::thread>(&QuickDecryptor::DataWriteLoop, this);
+
+    completion_event.Wait();
+    is_running = false;
+
+    read_thread->join();
+    decrypt_thread->join();
+    write_thread->join();
+
+    bool ret = is_good;
+    is_good = true;
+    return ret;
+}
+
+void QuickDecryptor::DataReadLoop() {
+    std::size_t current_buffer = 0;
+    bool is_first_run = true;
+
+    FileUtil::IOFile file(root_folder + source, "rb");
+    if (!file) {
+        is_good = false;
+        completion_event.Set();
+        return;
+    }
+
+    std::size_t file_size = total_size;
+
+    while (is_running && file_size > 0) {
+        if (is_first_run) {
+            if (current_buffer == buffers.size() - 1) {
+                is_first_run = false;
+            }
+        } else {
+            data_written_event[current_buffer].Wait();
+        }
+
+        const auto bytes_to_read = std::min(BufferSize, file_size);
+        if (file.ReadBytes(buffers[current_buffer].data(), bytes_to_read) != bytes_to_read) {
+            is_good = false;
+            completion_event.Set();
+            return;
+        }
+        file_size -= bytes_to_read;
+
+        data_read_event[current_buffer].Set();
+        current_buffer = (current_buffer + 1) % buffers.size();
+    }
+}
+
+void QuickDecryptor::DataDecryptLoop() {
+    auto ctr = GetFileCTR(source);
+    auto key = Key::GetNormalKey(Key::SDKey);
+    CryptoPP::CTR_Mode<CryptoPP::AES>::Decryption aes;
+    aes.SetKeyWithIV(key.data(), key.size(), ctr.data());
+
+    std::size_t current_buffer = 0;
+    std::size_t file_size = total_size;
+
+    while (is_running && file_size > 0) {
+        data_read_event[current_buffer].Wait();
+
+        const auto bytes_to_process = std::min(BufferSize, file_size);
+        aes.ProcessData(buffers[current_buffer].data(), buffers[current_buffer].data(),
+                        bytes_to_process);
+
+        file_size -= bytes_to_process;
+
+        data_decrypted_event[current_buffer].Set();
+        current_buffer = (current_buffer + 1) % buffers.size();
+    }
+}
+
+void QuickDecryptor::DataWriteLoop() {
+    std::size_t current_buffer = 0;
+
+    FileUtil::IOFile file(destination, "wb");
+    if (!file) {
+        is_good = false;
+        completion_event.Set();
+        return;
+    }
+
+    std::size_t file_size = total_size;
+    std::size_t iteration = 0;
+    /// The number of iterations each progress report covers. 32 * 16K = 512K
+    constexpr std::size_t ProgressReportFreq = 32;
+
+    while (is_running && file_size > 0) {
+        iteration++;
+        if (iteration % ProgressReportFreq == 0) {
+            callback(iteration * BufferSize, total_size);
+        }
+
+        data_decrypted_event[current_buffer].Wait();
+
+        const auto bytes_to_write = std::min(BufferSize, file_size);
+        if (file.WriteBytes(buffers[current_buffer].data(), bytes_to_write) != bytes_to_write) {
+            is_good = false;
+            completion_event.Set();
+            return;
+        }
+        file_size -= bytes_to_write;
+
+        data_written_event[current_buffer].Set();
+        current_buffer = (current_buffer + 1) % buffers.size();
+    }
+
+    completion_event.Set();
+}
+
+void QuickDecryptor::Abort() {
+    if (is_running.exchange(false)) {
+        is_good = false;
+        completion_event.Set();
+    }
+}
+
+} // namespace Core

src/core/quick_decryptor.h

@@ -0,0 +1,62 @@
+// Copyright 2019 threeSD Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <atomic>
+#include <memory>
+#include <string>
+#include "common/common_types.h"
+#include "common/thread.h"
+
+namespace Core {
+
+class QuickDecryptor {
+public:
+    /// (current_size, total_size)
+    using ProgressCallback = std::function<void(std::size_t, std::size_t)>;
+
+    /**
+     * Initializes the decryptor.
+     * @param root_folder Path to the "Nintendo 3DS/<ID0>/<ID1>" folder.
+     */
+    explicit QuickDecryptor(const std::string& root_folder);
+
+    ~QuickDecryptor();
+
+    bool DecryptAndWriteFile(const std::string& source, const std::string& destination,
+                             const ProgressCallback& callback = [](std::size_t, std::size_t) {});
+
+    void DataReadLoop();
+    void DataDecryptLoop();
+    void DataWriteLoop();
+
+    void Abort();
+
+private:
+    static constexpr std::size_t BufferSize = 16 * 1024; // 16 KB
+
+    std::string root_folder;
+    std::string source;
+    std::string destination;
+    std::size_t total_size{};
+
+    std::array<std::array<u8, BufferSize>, 3> buffers;
+    std::array<Common::Event, 3> data_read_event;
+    std::array<Common::Event, 3> data_decrypted_event;
+    std::array<Common::Event, 3> data_written_event;
+
+    std::unique_ptr<std::thread> read_thread;
+    std::unique_ptr<std::thread> decrypt_thread;
+    std::unique_ptr<std::thread> write_thread;
+
+    ProgressCallback callback;
+
+    Common::Event completion_event;
+    bool is_good{true};
+    std::atomic_bool is_running{false};
+};
+
+} // namespace Core

src/frontend/import_dialog.cpp

@@ -266,18 +266,32 @@ void ImportDialog::StartImporting() {
     auto* dialog = new QProgressDialog(tr("Initializing..."), tr("Cancel"), 0,
                                        static_cast<int>(total_size / multiplier), this);
     dialog->setWindowModality(Qt::WindowModal);
+    dialog->setMinimumDuration(0);
     dialog->setValue(0);
 
     auto* job = new ImportJob(this, importer, std::move(to_import));
 
-    connect(job, &ImportJob::ProgressUpdated, this,
-            [dialog, multiplier, total_count](u64 size_imported, u64 count,
-                                              Core::ContentSpecifier next_content) {
+    connect(job, &ImportJob::NextContent, this,
+            [this, dialog, multiplier, total_count](u64 size_imported, u64 count,
+                                                    Core::ContentSpecifier next_content) {
                 dialog->setValue(static_cast<int>(size_imported / multiplier));
-                dialog->setLabelText(tr("Importing %1 (%2/%3)...")
-                                         .arg(GetContentName(next_content))
+                dialog->setLabelText(tr("(%1/%2) Importing %3...")
                                          .arg(count)
-                                         .arg(total_count));
+                                         .arg(total_count)
+                                         .arg(GetContentName(next_content)));
+                current_content = next_content;
+                current_count = count;
+            });
+    connect(job, &ImportJob::ProgressUpdated, this,
+            [this, dialog, multiplier, total_count](u64 total_size_imported,
+                                                    u64 current_size_imported) {
+                dialog->setValue(static_cast<int>(total_size_imported / multiplier));
+                dialog->setLabelText(tr("(%1/%2) Importing %3 (%4/%5)...")
+                                         .arg(current_count)
+                                         .arg(total_count)
+                                         .arg(GetContentName(current_content))
+                                         .arg(ReadableByteSize(current_size_imported))
+                                         .arg(ReadableByteSize(current_content.maximum_size)));
             });
     connect(job, &ImportJob::ErrorOccured, this,
             [this, dialog](Core::ContentSpecifier current_content) {

src/frontend/import_dialog.h

@@ -41,4 +41,8 @@ private:
     // HACK: To tell whether the checkbox state change is a programmatic trigger
     // TODO: Is there a more elegant way of doing the same?
     bool program_trigger = false;
+
+    // TODO: Why this won't work as locals?
+    Core::ContentSpecifier current_content = {};
+    u64 current_count = 0;
 };

src/frontend/import_job.cpp

@@ -15,10 +15,17 @@ ImportJob::~ImportJob() = default;
 void ImportJob::run() {
     u64 size_imported = 0, count = 0;
     for (const auto& content : contents) {
-        emit ProgressUpdated(size_imported, count + 1, content);
-        if (!importer.ImportContent(content)) {
-            emit ErrorOccured(content);
-            return;
+        emit NextContent(size_imported, count + 1, content);
+        const auto callback = [this, size_imported](std::size_t current_size,
+                                                    std::size_t /*total_size*/) {
+            emit ProgressUpdated(size_imported + current_size, current_size);
+        };
+        if (!importer.ImportContent(content, callback)) {
+            importer.DeleteContent(content);
+            if (!cancelled) {
+                emit ErrorOccured(content);
+                return;
+            }
         }
         count++;
         size_imported += content.maximum_size;
@@ -32,4 +39,5 @@ void ImportJob::run() {
 
 void ImportJob::Cancel() {
     cancelled.store(true);
+    importer.Abort();
 }

src/frontend/import_job.h

@@ -20,7 +20,17 @@ public:
     void Cancel();
 
 signals:
-    void ProgressUpdated(u64 size_imported, u64 count, Core::ContentSpecifier next_content);
+    /**
+     * Called when progress is updated on the current content.
+     * @param total_size_imported Total imported size taking all previous contents into
+     * consideration.
+     * @param current_size_imported Imported size of the current content.
+     */
+    void ProgressUpdated(u64 total_size_imported, u64 current_size_imported);
+
+    /// Dumping of a content has been finished, go on to the next. Called at start as well.
+    void NextContent(u64 size_imported, u64 count, Core::ContentSpecifier next_content);
+
     void Completed();
     void ErrorOccured(Core::ContentSpecifier current_content);