CMake, Big Cleanup, CI Build and 3rd_Party

WIP/fs/savedata_factory.cpp

@@ -0,0 +1,194 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <memory>
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "common/logging/log.h"
+#include "common/uuid.h"
+#include "core/core.h"
+#include "core/file_sys/savedata_factory.h"
+#include "core/file_sys/vfs/vfs.h"
+
+namespace FileSys {
+
+namespace {
+
+bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataAttribute& attr) {
+    return attr.type == SaveDataType::Cache || attr.type == SaveDataType::Temporary ||
+           (space == SaveDataSpaceId::User && ///< Normal Save Data -- Current Title & User
+            (attr.type == SaveDataType::Account || attr.type == SaveDataType::Device) &&
+            attr.program_id == 0 && attr.system_save_data_id == 0);
+}
+
+std::string GetFutureSaveDataPath(SaveDataSpaceId space_id, SaveDataType type, u64 title_id,
+                                  u128 user_id) {
+    // Only detect nand user saves.
+    const auto space_id_path = [space_id]() -> std::string_view {
+        switch (space_id) {
+        case SaveDataSpaceId::User:
+            return "/user/save";
+        default:
+            return "";
+        }
+    }();
+
+    if (space_id_path.empty()) {
+        return "";
+    }
+
+    Common::UUID uuid;
+    std::memcpy(uuid.uuid.data(), user_id.data(), sizeof(Common::UUID));
+
+    // Only detect account/device saves from the future location.
+    switch (type) {
+    case SaveDataType::Account:
+        return fmt::format("{}/account/{}/{:016X}/0", space_id_path, uuid.RawString(), title_id);
+    case SaveDataType::Device:
+        return fmt::format("{}/device/{:016X}/0", space_id_path, title_id);
+    default:
+        return "";
+    }
+}
+
+} // Anonymous namespace
+
+SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,
+                                 VirtualDir save_directory_)
+    : system{system_}, program_id{program_id_}, dir{std::move(save_directory_)} {
+    // Delete all temporary storages
+    // On hardware, it is expected that temporary storage be empty at first use.
+    dir->DeleteSubdirectoryRecursive("temp");
+}
+
+SaveDataFactory::~SaveDataFactory() = default;
+
+VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);
+
+    return dir->CreateDirectoryRelative(save_directory);
+}
+
+VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
+
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);
+
+    auto out = dir->GetDirectoryRelative(save_directory);
+
+    if (out == nullptr && (ShouldSaveDataBeAutomaticallyCreated(space, meta) && auto_create)) {
+        return Create(space, meta);
+    }
+
+    return out;
+}
+
+VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
+    return dir->GetDirectoryRelative(GetSaveDataSpaceIdPath(space));
+}
+
+std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
+    switch (space) {
+    case SaveDataSpaceId::System:
+        return "/system/";
+    case SaveDataSpaceId::User:
+        return "/user/";
+    case SaveDataSpaceId::Temporary:
+        return "/temp/";
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
+        return "/unrecognized/"; ///< To prevent corruption when ignoring asserts.
+    }
+}
+
+std::string SaveDataFactory::GetFullPath(ProgramId program_id, VirtualDir dir,
+                                         SaveDataSpaceId space, SaveDataType type, u64 title_id,
+                                         u128 user_id, u64 save_id) {
+    // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
+    // be interpreted as the title id of the current process.
+    if (type == SaveDataType::Account || type == SaveDataType::Device) {
+        if (title_id == 0) {
+            title_id = program_id;
+        }
+    }
+
+    // For compat with a future impl.
+    if (std::string future_path =
+            GetFutureSaveDataPath(space, type, title_id & ~(0xFFULL), user_id);
+        !future_path.empty()) {
+        // Check if this location exists, and prefer it over the old.
+        if (const auto future_dir = dir->GetDirectoryRelative(future_path); future_dir != nullptr) {
+            LOG_INFO(Service_FS, "Using save at new location: {}", future_path);
+            return future_path;
+        }
+    }
+
+    std::string out = GetSaveDataSpaceIdPath(space);
+
+    switch (type) {
+    case SaveDataType::System:
+        return fmt::format("{}save/{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);
+    case SaveDataType::Account:
+    case SaveDataType::Device:
+        return fmt::format("{}save/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+                           title_id);
+    case SaveDataType::Temporary:
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+                           title_id);
+    case SaveDataType::Cache:
+        return fmt::format("{}save/cache/{:016X}", out, title_id);
+    default:
+        ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));
+        return fmt::format("{}save/unknown_{:X}/{:016X}", out, static_cast<u8>(type), title_id);
+    }
+}
+
+std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future) {
+    if (future) {
+        Common::UUID uuid;
+        std::memcpy(uuid.uuid.data(), user_id.data(), sizeof(Common::UUID));
+        return fmt::format("/user/save/account/{}", uuid.RawString());
+    }
+    return fmt::format("/user/save/{:016X}/{:016X}{:016X}", 0, user_id[1], user_id[0]);
+}
+
+SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
+                                               u128 user_id) const {
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
+
+    const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName());
+    if (size_file == nullptr || size_file->GetSize() < sizeof(SaveDataSize)) {
+        return {0, 0};
+    }
+
+    SaveDataSize out;
+    if (size_file->ReadObject(&out) != sizeof(SaveDataSize)) {
+        return {0, 0};
+    }
+
+    return out;
+}
+
+void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
+                                        SaveDataSize new_value) const {
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
+
+    const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName());
+    if (size_file == nullptr) {
+        return;
+    }
+
+    size_file->Resize(sizeof(SaveDataSize));
+    size_file->WriteObject(new_value);
+}
+
+void SaveDataFactory::SetAutoCreate(bool state) {
+    auto_create = state;
+}
+
+} // namespace FileSys