dmnt-cheat: Implement frozen addresses

stratosphere/dmnt/source/dmnt_cheat_manager.cpp

@@ -14,6 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
  
+#include <map>
 #include <switch.h>
 #include "dmnt_cheat_manager.hpp"
 #include "dmnt_cheat_vm.hpp"
@@ -32,6 +33,9 @@ static Handle g_cheat_process_debug_hnd = 0;
 /* Global cheat entry storage. */
 static CheatEntry g_cheat_entries[DmntCheatManager::MaxCheatCount];
 
+/* Global frozen address storage. */
+static std::map<u64, FrozenAddressValue> g_frozen_addresses_map;
+
 void DmntCheatManager::CloseActiveCheatProcess() {
     if (g_cheat_process_debug_hnd != 0) {
         /* Close process resources. */
@@ -42,6 +46,9 @@ void DmntCheatManager::CloseActiveCheatProcess() {
         /* Clear cheat list. */
         ResetAllCheatEntries();
         
+        /* Clear frozen addresses. */
+        ResetFrozenAddresses();
+        
         /* Signal to our fans. */
         g_cheat_process_event->Signal();
     }
@@ -186,6 +193,11 @@ Result DmntCheatManager::QueryCheatProcessMemory(MemoryInfo *mapping, u64 addres
     return ResultDmntCheatNotAttached;
 }
 
+void DmntCheatManager::ResetFrozenAddresses() {
+    /* Just clear the map. */
+    g_frozen_addresses_map.clear();
+}
+
 void DmntCheatManager::ResetCheatEntry(size_t i) {
     if (i < DmntCheatManager::MaxCheatCount) {
         g_cheat_entries[i].enabled = false;
@@ -466,6 +478,102 @@ Result DmntCheatManager::RemoveCheat(u32 cheat_id) {
     return 0;
 }
 
+Result DmntCheatManager::GetFrozenAddressCount(u64 *out_count) {
+    std::scoped_lock<HosMutex> lk(g_cheat_lock);
+    
+    if (!HasActiveCheatProcess()) {
+        return ResultDmntCheatNotAttached;
+    }
+    
+    *out_count = g_frozen_addresses_map.size();
+    return 0;
+}
+
+Result DmntCheatManager::GetFrozenAddresses(FrozenAddressEntry *frz_addrs, size_t max_count, u64 *out_count, u64 offset) {
+    std::scoped_lock<HosMutex> lk(g_cheat_lock);
+    
+    if (!HasActiveCheatProcess()) {
+        return ResultDmntCheatNotAttached;
+    }
+    
+    u64 count = 0;
+    *out_count = 0;
+    for (auto const& [address, value] : g_frozen_addresses_map) {
+        if ((*out_count) >= max_count) {
+            break;
+        }
+        
+        count++;
+        if (count > offset) {
+            const u64 cur_ind = (*out_count)++;
+            frz_addrs[cur_ind].address = address;
+            frz_addrs[cur_ind].value = value;
+        }
+    }
+    
+    return 0;
+}
+
+Result  DmntCheatManager::GetFrozenAddress(FrozenAddressEntry *frz_addr, u64 address) {
+    std::scoped_lock<HosMutex> lk(g_cheat_lock);
+    
+    if (!HasActiveCheatProcess()) {
+        return ResultDmntCheatNotAttached;
+    }
+    
+    const auto it = g_frozen_addresses_map.find(address);
+    if (it == g_frozen_addresses_map.end()) {
+        return ResultDmntCheatAddressNotFrozen;
+    }
+    
+    frz_addr->address = it->first;
+    frz_addr->value = it->second;
+    return 0;
+}
+
+Result DmntCheatManager::EnableFrozenAddress(u64 address, u64 width) {
+    std::scoped_lock<HosMutex> lk(g_cheat_lock);
+    
+    if (!HasActiveCheatProcess()) {
+        return ResultDmntCheatNotAttached;
+    }
+    
+    if (g_frozen_addresses_map.size() >= DmntCheatManager::MaxFrozenAddressCount) {
+        return ResultDmntCheatTooManyFrozenAddresses;
+    }
+    
+    const auto it = g_frozen_addresses_map.find(address);
+    if (it != g_frozen_addresses_map.end()) {
+        return ResultDmntCheatAddressAlreadyFrozen;
+    }
+    
+    Result rc;
+    FrozenAddressValue value = {0};
+    value.width = width;
+    if (R_FAILED((rc = ReadCheatProcessMemoryForVm(address, &value.value, width)))) {
+        return rc;
+    }
+    
+    g_frozen_addresses_map[address] = value;
+    return 0;
+}
+
+Result DmntCheatManager::DisableFrozenAddress(u64 address) {
+    std::scoped_lock<HosMutex> lk(g_cheat_lock);
+    
+    if (!HasActiveCheatProcess()) {
+        return ResultDmntCheatNotAttached;
+    }
+    
+    const auto it = g_frozen_addresses_map.find(address);
+    if (it == g_frozen_addresses_map.end()) {
+        return ResultDmntCheatAddressNotFrozen;
+    }
+    
+    g_frozen_addresses_map.erase(address);
+    return 0;
+}
+
 Handle DmntCheatManager::PrepareDebugNextApplication() {
     Result rc;
     Handle event_h;
@@ -691,6 +799,11 @@ void DmntCheatManager::VmThread(void *arg) {
                         g_cheat_vm->Execute(&g_cheat_process_metadata);
                     }
                 }
+                
+                /* Apply frozen addresses. */
+                for (auto const& [address, value] : g_frozen_addresses_map) {
+                    WriteCheatProcessMemoryForVm(address, &value.value, value.width);
+                }
             }
         }
         svcSleepThread(0x5000000ul);

stratosphere/dmnt/source/dmnt_cheat_manager.hpp

@@ -23,6 +23,7 @@
 class DmntCheatManager {
     public:
         static constexpr size_t MaxCheatCount = 0x80;
+        static constexpr size_t MaxFrozenAddressCount = 0x80;
     private:
         static Handle PrepareDebugNextApplication();
         static void OnNewApplicationLaunch();
@@ -39,6 +40,8 @@ class DmntCheatManager {
         static CheatEntry *GetCheatEntryById(size_t i);
         static bool ParseCheats(const char *cht_txt, size_t len);
         static bool LoadCheats(u64 title_id, const u8 *build_id);
+        
+        static void ResetFrozenAddresses();
     public:
         static bool GetHasActiveCheatProcess();
         static Handle GetCheatProcessEventHandle();
@@ -61,5 +64,11 @@ class DmntCheatManager {
         static Result AddCheat(u32 *out_id, CheatDefinition *def, bool enabled);
         static Result RemoveCheat(u32 cheat_id);
         
+        static Result GetFrozenAddressCount(u64 *out_count);
+        static Result GetFrozenAddresses(FrozenAddressEntry *frz_addrs, size_t max_count, u64 *out_count, u64 offset);
+        static Result GetFrozenAddress(FrozenAddressEntry *frz_addr, u64 address);
+        static Result EnableFrozenAddress(u64 address, u64 width);
+        static Result DisableFrozenAddress(u64 address);
+        
         static void InitializeCheatManager();
 };

stratosphere/dmnt/source/dmnt_cheat_service.cpp

@@ -143,16 +143,35 @@ Result DmntCheatService::RemoveCheat(u32 cheat_id) {
 /* ========================================================================================= */
 
 Result DmntCheatService::GetFrozenAddressCount(Out<u64> out_count) {
-    /* TODO */
-    return 0xF601;
+    return DmntCheatManager::GetFrozenAddressCount(out_count.GetPointer());
 }
 
-Result DmntCheatService::GetFrozenAddresses(OutBuffer<uintptr_t> addresses, Out<u64> out_count, u64 offset) {
-    /* TODO */
-    return 0xF601;
+Result DmntCheatService::GetFrozenAddresses(OutBuffer<FrozenAddressEntry> frz_addrs, Out<u64> out_count, u64 offset) {
+    if (frz_addrs.buffer == nullptr) {
+        return ResultDmntCheatNullBuffer;
+    }
+    
+    return DmntCheatManager::GetFrozenAddresses(frz_addrs.buffer, frz_addrs.num_elements, out_count.GetPointer(), offset);
 }
 
-Result DmntCheatService::ToggleAddressFrozen(uintptr_t address) {
-    /* TODO */
-    return 0xF601;
+Result DmntCheatService::GetFrozenAddress(Out<FrozenAddressEntry> entry, u64 address) {
+    return DmntCheatManager::GetFrozenAddress(entry.GetPointer(), address);
+}
+
+Result DmntCheatService::EnableFrozenAddress(u64 address, u64 width) {
+    switch (width) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+            break;
+        default:
+            return ResultDmntCheatInvalidFreezeWidth;
+    }
+    
+    return DmntCheatManager::EnableFrozenAddress(address, width);
+}
+
+Result DmntCheatService::DisableFrozenAddress(u64 address) {
+    return DmntCheatManager::DisableFrozenAddress(address);
 }

stratosphere/dmnt/source/dmnt_cheat_service.hpp

@@ -45,7 +45,9 @@ enum DmntCheatCmd {
     /* Interact with Frozen Addresses */
     DmntCheat_Cmd_GetFrozenAddressCount = 65300,
     DmntCheat_Cmd_GetFrozenAddresses = 65301,
-    DmntCheat_Cmd_ToggleAddressFrozen = 65302,
+    DmntCheat_Cmd_GetFrozenAddress = 65302,
+    DmntCheat_Cmd_EnableFrozenAddress = 65303,
+    DmntCheat_Cmd_DisableFrozenAddress = 65304,
 };
 
 class DmntCheatService final : public IServiceObject {
@@ -69,8 +71,10 @@ class DmntCheatService final : public IServiceObject {
         Result RemoveCheat(u32 cheat_id);
         
         Result GetFrozenAddressCount(Out<u64> out_count);
-        Result GetFrozenAddresses(OutBuffer<uintptr_t> addresses, Out<u64> out_count, u64 offset);
-        Result ToggleAddressFrozen(uintptr_t address);
+        Result GetFrozenAddresses(OutBuffer<FrozenAddressEntry> addresses, Out<u64> out_count, u64 offset);
+        Result GetFrozenAddress(Out<FrozenAddressEntry> entry, u64 address);
+        Result EnableFrozenAddress(u64 address, u64 width);
+        Result DisableFrozenAddress(u64 address);
 
     public:
         DEFINE_SERVICE_DISPATCH_TABLE {
@@ -94,6 +98,8 @@ class DmntCheatService final : public IServiceObject {
 
             MakeServiceCommandMeta<DmntCheat_Cmd_GetFrozenAddressCount, &DmntCheatService::GetFrozenAddressCount>(),
             MakeServiceCommandMeta<DmntCheat_Cmd_GetFrozenAddresses, &DmntCheatService::GetFrozenAddresses>(),
-            MakeServiceCommandMeta<DmntCheat_Cmd_ToggleAddressFrozen, &DmntCheatService::ToggleAddressFrozen>(),
+            MakeServiceCommandMeta<DmntCheat_Cmd_GetFrozenAddress, &DmntCheatService::GetFrozenAddress>(),
+            MakeServiceCommandMeta<DmntCheat_Cmd_EnableFrozenAddress, &DmntCheatService::EnableFrozenAddress>(),
+            MakeServiceCommandMeta<DmntCheat_Cmd_DisableFrozenAddress, &DmntCheatService::DisableFrozenAddress>(),
         };
 };

stratosphere/dmnt/source/dmnt_cheat_types.hpp

@@ -45,4 +45,14 @@ struct CheatEntry {
     bool enabled;
     uint32_t cheat_id;
     CheatDefinition definition;
+};
+
+struct FrozenAddressValue {
+    u64 value;
+    u8 width;
+};
+
+struct FrozenAddressEntry {
+    u64 address;
+    FrozenAddressValue value;
 };

stratosphere/dmnt/source/dmnt_results.hpp

@@ -28,4 +28,9 @@ static constexpr Result ResultDmntCheatNullBuffer    = MAKERESULT(Module_Dmnt, 6
 static constexpr Result ResultDmntCheatInvalidBuffer = MAKERESULT(Module_Dmnt, 6502);
 static constexpr Result ResultDmntCheatUnknownChtId  = MAKERESULT(Module_Dmnt, 6503);
 static constexpr Result ResultDmntCheatOutOfCheats   = MAKERESULT(Module_Dmnt, 6504);
-static constexpr Result ResultDmntCheatInvalidCheat  = MAKERESULT(Module_Dmnt, 6505);
+static constexpr Result ResultDmntCheatInvalidCheat  = MAKERESULT(Module_Dmnt, 6505);
+
+static constexpr Result ResultDmntCheatInvalidFreezeWidth     = MAKERESULT(Module_Dmnt, 6600);
+static constexpr Result ResultDmntCheatAddressAlreadyFrozen   = MAKERESULT(Module_Dmnt, 6601);
+static constexpr Result ResultDmntCheatAddressNotFrozen       = MAKERESULT(Module_Dmnt, 6602);
+static constexpr Result ResultDmntCheatTooManyFrozenAddresses = MAKERESULT(Module_Dmnt, 6603);