svc: Updated svc names

src/core/file_sys/control_metadata.cpp

@@ -8,14 +8,6 @@
 
 namespace FileSys {
 
-const std::array<const char*, 15> LANGUAGE_NAMES = {
-    "AmericanEnglish", "BritishEnglish", "Japanese",
-    "French",          "German",         "LatinAmericanSpanish",
-    "Spanish",         "Italian",        "Dutch",
-    "CanadianFrench",  "Portugese",      "Russian",
-    "Korean",          "Taiwanese",      "Chinese",
-};
-
 std::string LanguageEntry::GetApplicationName() const {
     return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(), 0x200);
 }
@@ -31,15 +23,15 @@ NACP::NACP(VirtualFile file) : raw(std::make_unique<RawNACP>()) {
 const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
     if (language != Language::Default) {
         return raw->language_entries.at(static_cast<u8>(language));
-    }
+    } else {
+        for (const auto& language_entry : raw->language_entries) {
+            if (!language_entry.GetApplicationName().empty())
+                return language_entry;
+        }
 
-    for (const auto& language_entry : raw->language_entries) {
-        if (!language_entry.GetApplicationName().empty())
-            return language_entry;
+        // Fallback to English
+        return GetLanguageEntry(Language::AmericanEnglish);
     }
-
-    // Fallback to English
-    return GetLanguageEntry(Language::AmericanEnglish);
 }
 
 std::string NACP::GetApplicationName(Language language) const {

src/core/file_sys/control_metadata.h

@@ -66,7 +66,12 @@ enum class Language : u8 {
     Default = 255,
 };
 
-extern const std::array<const char*, 15> LANGUAGE_NAMES;
+static constexpr std::array<const char*, 15> LANGUAGE_NAMES = {
+    "AmericanEnglish", "BritishEnglish", "Japanese",
+    "French",          "German",         "LatinAmericanSpanish",
+    "Spanish",         "Italian",        "Dutch",
+    "CanadianFrench",  "Portugese",      "Russian",
+    "Korean",          "Taiwanese",      "Chinese"};
 
 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.

src/core/file_sys/savedata_factory.cpp

@@ -85,10 +85,10 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
 
     switch (space) {
     case SaveDataSpaceId::NandSystem:
-        out = "/system/";
+        out = "/system/save/";
         break;
     case SaveDataSpaceId::NandUser:
-        out = "/user/";
+        out = "/user/save/";
         break;
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
@@ -96,12 +96,9 @@ std::string SaveDataFactory::GetFullPath(SaveDataSpaceId space, SaveDataType typ
 
     switch (type) {
     case SaveDataType::SystemSaveData:
-        return fmt::format("{}save/{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);
+        return fmt::format("{}{:016X}/{:016X}{:016X}", out, save_id, user_id[1], user_id[0]);
     case SaveDataType::SaveData:
-        return fmt::format("{}save/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
-                           title_id);
-    case SaveDataType::TemporaryStorage:
-        return fmt::format("{}temp/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
     default:
         ASSERT_MSG(false, "Unrecognized SaveDataType: {:02X}", static_cast<u8>(type));

src/core/file_sys/xts_archive.cpp

@@ -30,6 +30,9 @@ static bool CalculateHMAC256(Destination* out, const SourceKey* key, std::size_t
     mbedtls_md_context_t context;
     mbedtls_md_init(&context);
 
+    const auto key_f = reinterpret_cast<const u8*>(key);
+    const std::vector<u8> key_v(key_f, key_f + key_length);
+
     if (mbedtls_md_setup(&context, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1) ||
         mbedtls_md_hmac_starts(&context, reinterpret_cast<const u8*>(key), key_length) ||
         mbedtls_md_hmac_update(&context, reinterpret_cast<const u8*>(data), data_length) ||
@@ -42,7 +45,7 @@ static bool CalculateHMAC256(Destination* out, const SourceKey* key, std::size_t
     return true;
 }
 
-NAX::NAX(VirtualFile file_) : header(std::make_unique<NAXHeader>()), file(std::move(file_)) {
+NAX::NAX(VirtualFile file_) : file(std::move(file_)), header(std::make_unique<NAXHeader>()) {
     std::string path = FileUtil::SanitizePath(file->GetFullPath());
     static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
                                            std::regex_constants::ECMAScript |
@@ -62,7 +65,7 @@ NAX::NAX(VirtualFile file_) : header(std::make_unique<NAXHeader>()), file(std::m
 }
 
 NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
-    : header(std::make_unique<NAXHeader>()), file(std::move(file_)) {
+    : file(std::move(file_)), header(std::make_unique<NAXHeader>()) {
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256(nca_id.data(), nca_id.size(), hash.data(), 0);
     status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],
@@ -135,9 +138,9 @@ VirtualFile NAX::GetDecrypted() const {
     return dec_file;
 }
 
-std::unique_ptr<NCA> NAX::AsNCA() const {
+std::shared_ptr<NCA> NAX::AsNCA() const {
     if (type == NAXContentType::NCA)
-        return std::make_unique<NCA>(GetDecrypted());
+        return std::make_shared<NCA>(GetDecrypted());
     return nullptr;
 }
 

src/core/file_sys/xts_archive.h

@@ -38,7 +38,7 @@ public:
 
     VirtualFile GetDecrypted() const;
 
-    std::unique_ptr<NCA> AsNCA() const;
+    std::shared_ptr<NCA> AsNCA() const;
 
     NAXContentType GetContentType() const;
 
@@ -60,7 +60,7 @@ private:
 
     VirtualFile file;
     Loader::ResultStatus status;
-    NAXContentType type{};
+    NAXContentType type;
 
     VirtualFile dec_file;
 

src/core/gdbstub/gdbstub.cpp

@@ -995,7 +995,7 @@ static bool CommitBreakpoint(BreakpointType type, VAddr addr, u64 len) {
     breakpoint.addr = addr;
     breakpoint.len = len;
     Memory::ReadBlock(addr, breakpoint.inst.data(), breakpoint.inst.size());
-    static constexpr std::array<u8, 4> btrap{{0x00, 0x7d, 0x20, 0xd4}};
+    static constexpr std::array<u8, 4> btrap{{0xd4, 0x20, 0x7d, 0x0}};
     Memory::WriteBlock(addr, btrap.data(), btrap.size());
     Core::System::GetInstance().InvalidateCpuInstructionCaches();
     p.insert({addr, breakpoint});

src/core/hle/kernel/svc.cpp

@@ -1039,7 +1039,7 @@ static const FunctionDef SVC_Table[] = {
     {0x2B, nullptr, "FlushDataCache"},
     {0x2C, nullptr, "MapPhysicalMemory"},
     {0x2D, nullptr, "UnmapPhysicalMemory"},
-    {0x2E, nullptr, "GetNextThreadInfo"},
+    {0x2E, nullptr, "GetFutureThreadInfo"},
     {0x2F, nullptr, "GetLastThreadInfo"},
     {0x30, nullptr, "GetResourceLimitLimitValue"},
     {0x31, nullptr, "GetResourceLimitCurrentValue"},
@@ -1065,11 +1065,11 @@ static const FunctionDef SVC_Table[] = {
     {0x45, nullptr, "CreateEvent"},
     {0x46, nullptr, "Unknown"},
     {0x47, nullptr, "Unknown"},
-    {0x48, nullptr, "AllocateUnsafeMemory"},
-    {0x49, nullptr, "FreeUnsafeMemory"},
-    {0x4A, nullptr, "SetUnsafeAllocationLimit"},
-    {0x4B, nullptr, "CreateJitMemory"},
-    {0x4C, nullptr, "MapJitMemory"},
+    {0x48, nullptr, "MapPhysicalMemoryUnsafe"},
+    {0x49, nullptr, "UnmapPhysicalMemoryUnsafe"},
+    {0x4A, nullptr, "SetUnsafeLimit"},
+    {0x4B, nullptr, "CreateCodeMemory"},
+    {0x4C, nullptr, "ControlCodeMemory"},
     {0x4D, nullptr, "SleepSystem"},
     {0x4E, nullptr, "ReadWriteRegister"},
     {0x4F, nullptr, "SetProcessActivity"},
@@ -1104,7 +1104,7 @@ static const FunctionDef SVC_Table[] = {
     {0x6C, nullptr, "SetHardwareBreakPoint"},
     {0x6D, nullptr, "GetDebugThreadParam"},
     {0x6E, nullptr, "Unknown"},
-    {0x6F, nullptr, "GetMemoryInfo"},
+    {0x6F, nullptr, "GetSystemInfo"},
     {0x70, nullptr, "CreatePort"},
     {0x71, nullptr, "ManageNamedPort"},
     {0x72, nullptr, "ConnectToPort"},

src/core/hle/service/nim/nim.cpp

@@ -2,10 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <chrono>
-#include <ctime>
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/service/nim/nim.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
@@ -104,111 +100,19 @@ public:
     }
 };
 
-class IEnsureNetworkClockAvailabilityService final
-    : public ServiceFramework<IEnsureNetworkClockAvailabilityService> {
-public:
-    IEnsureNetworkClockAvailabilityService()
-        : ServiceFramework("IEnsureNetworkClockAvailabilityService") {
-        static const FunctionInfo functions[] = {
-            {0, &IEnsureNetworkClockAvailabilityService::StartTask, "StartTask"},
-            {1, &IEnsureNetworkClockAvailabilityService::GetFinishNotificationEvent,
-             "GetFinishNotificationEvent"},
-            {2, &IEnsureNetworkClockAvailabilityService::GetResult, "GetResult"},
-            {3, &IEnsureNetworkClockAvailabilityService::Cancel, "Cancel"},
-            {4, &IEnsureNetworkClockAvailabilityService::IsProcessing, "IsProcessing"},
-            {5, &IEnsureNetworkClockAvailabilityService::GetServerTime, "GetServerTime"},
-        };
-        RegisterHandlers(functions);
-
-        auto& kernel = Core::System::GetInstance().Kernel();
-        finished_event =
-            Kernel::Event::Create(kernel, Kernel::ResetType::OneShot,
-                                  "IEnsureNetworkClockAvailabilityService:FinishEvent");
-    }
-
-private:
-    Kernel::SharedPtr<Kernel::Event> finished_event;
-
-    void StartTask(Kernel::HLERequestContext& ctx) {
-        // No need to connect to the internet, just finish the task straight away.
-        finished_event->Signal();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_NIM, "called");
-    }
-
-    void GetFinishNotificationEvent(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(finished_event);
-        LOG_DEBUG(Service_NIM, "called");
-    }
-
-    void GetResult(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_NIM, "called");
-    }
-
-    void Cancel(Kernel::HLERequestContext& ctx) {
-        finished_event->Clear();
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_DEBUG(Service_NIM, "called");
-    }
-
-    void IsProcessing(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<u32>(0); // We instantly process the request
-        LOG_DEBUG(Service_NIM, "called");
-    }
-
-    void GetServerTime(Kernel::HLERequestContext& ctx) {
-        const s64 server_time{std::chrono::duration_cast<std::chrono::seconds>(
-                                  std::chrono::system_clock::now().time_since_epoch())
-                                  .count()};
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw<s64>(server_time);
-        LOG_DEBUG(Service_NIM, "called");
-    }
-};
-
 class NTC final : public ServiceFramework<NTC> {
 public:
     explicit NTC() : ServiceFramework{"ntc"} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, &NTC::OpenEnsureNetworkClockAvailabilityService, "OpenEnsureNetworkClockAvailabilityService"},
-            {100, &NTC::SuspendAutonomicTimeCorrection, "SuspendAutonomicTimeCorrection"},
-            {101, &NTC::ResumeAutonomicTimeCorrection, "ResumeAutonomicTimeCorrection"},
+            {0, nullptr, "OpenEnsureNetworkClockAvailabilityService"},
+            {100, nullptr, "SuspendAutonomicTimeCorrection"},
+            {101, nullptr, "ResumeAutonomicTimeCorrection"},
         };
         // clang-format on
 
         RegisterHandlers(functions);
     }
-
-private:
-    void OpenEnsureNetworkClockAvailabilityService(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IEnsureNetworkClockAvailabilityService>();
-        LOG_DEBUG(Service_NIM, "called");
-    }
-
-    // TODO(ogniK): Do we need these?
-    void SuspendAutonomicTimeCorrection(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_NIM, "(STUBBED) called");
-    }
-
-    void ResumeAutonomicTimeCorrection(Kernel::HLERequestContext& ctx) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-        LOG_WARNING(Service_NIM, "(STUBBED) called");
-    }
 };
 
 void InstallInterfaces(SM::ServiceManager& sm) {

src/core/loader/nax.cpp

@@ -11,20 +11,6 @@
 #include "core/loader/nca.h"
 
 namespace Loader {
-namespace {
-FileType IdentifyTypeImpl(const FileSys::NAX& nax) {
-    if (nax.GetStatus() != ResultStatus::Success) {
-        return FileType::Error;
-    }
-
-    const auto nca = nax.AsNCA();
-    if (nca == nullptr || nca->GetStatus() != ResultStatus::Success) {
-        return FileType::Error;
-    }
-
-    return FileType::NAX;
-}
-} // Anonymous namespace
 
 AppLoader_NAX::AppLoader_NAX(FileSys::VirtualFile file)
     : AppLoader(file), nax(std::make_unique<FileSys::NAX>(file)),
@@ -33,12 +19,14 @@ AppLoader_NAX::AppLoader_NAX(FileSys::VirtualFile file)
 AppLoader_NAX::~AppLoader_NAX() = default;
 
 FileType AppLoader_NAX::IdentifyType(const FileSys::VirtualFile& file) {
-    const FileSys::NAX nax(file);
-    return IdentifyTypeImpl(nax);
-}
+    FileSys::NAX nax(file);
 
-FileType AppLoader_NAX::GetFileType() {
-    return IdentifyTypeImpl(*nax);
+    if (nax.GetStatus() == ResultStatus::Success && nax.AsNCA() != nullptr &&
+        nax.AsNCA()->GetStatus() == ResultStatus::Success) {
+        return FileType::NAX;
+    }
+
+    return FileType::Error;
 }
 
 ResultStatus AppLoader_NAX::Load(Kernel::SharedPtr<Kernel::Process>& process) {

src/core/loader/nax.h

@@ -31,7 +31,9 @@ public:
      */
     static FileType IdentifyType(const FileSys::VirtualFile& file);
 
-    FileType GetFileType() override;
+    FileType GetFileType() override {
+        return IdentifyType(file);
+    }
 
     ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;