From f4950ff26e0b1c766f87384183d3f5640ee955d6 Mon Sep 17 00:00:00 2001 From: Michael Scire Date: Mon, 25 Mar 2019 10:35:08 -0700 Subject: [PATCH] dmnt-cheat: Add support for saving/restoring cheat toggle state --- common/defaults/system_settings.ini | 6 +- .../dmnt/source/dmnt_cheat_manager.cpp | 479 ++++++++++++------ .../dmnt/source/dmnt_cheat_manager.hpp | 5 + 3 files changed, 333 insertions(+), 157 deletions(-) diff --git a/common/defaults/system_settings.ini b/common/defaults/system_settings.ini index 86e211793..d1b7418b9 100644 --- a/common/defaults/system_settings.ini +++ b/common/defaults/system_settings.ini @@ -11,4 +11,8 @@ usb30_force_enabled = u8!0x0 power_menu_reboot_function = str!payload ; Controls whether dmnt cheats should be toggled on or off by ; default. 1 = toggled on by default, 0 = toggled off by default. -dmnt_cheats_enabled_by_default = u8!0x1 \ No newline at end of file +dmnt_cheats_enabled_by_default = u8!0x1 +; Controls whether dmnt should always save cheat toggle state +; for restoration on new game launch. 1 = always save toggles, +; 0 = only save toggles if toggle file exists. +dmnt_always_save_cheat_toggles = u8!0x0 \ No newline at end of file diff --git a/stratosphere/dmnt/source/dmnt_cheat_manager.cpp b/stratosphere/dmnt/source/dmnt_cheat_manager.cpp index ba44fdfa0..fd7234d4b 100644 --- a/stratosphere/dmnt/source/dmnt_cheat_manager.cpp +++ b/stratosphere/dmnt/source/dmnt_cheat_manager.cpp @@ -13,7 +13,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - + #include #include #include "dmnt_cheat_manager.hpp" @@ -33,6 +33,8 @@ static Handle g_cheat_process_debug_hnd = 0; /* Should we enable cheats by default? */ static bool g_enable_cheats_by_default = true; +static bool g_always_save_cheat_toggles = false; +static bool g_should_save_cheat_toggles = false; /* For debug event thread management. */ static HosMutex g_debug_event_thread_lock, g_attach_lock; @@ -49,31 +51,31 @@ static std::map g_frozen_addresses_map; void DmntCheatManager::StartDebugEventsThread() { std::scoped_lock lk(g_debug_event_thread_lock); - + /* Spawn the debug events thread. */ if (!g_has_debug_events_thread) { Result rc; - + if (R_FAILED((rc = g_debug_events_thread.Initialize(&DmntCheatManager::DebugEventsThread, nullptr, 0x4000, 48)))) { return fatalSimple(rc); } - + if (R_FAILED((rc = g_debug_events_thread.Start()))) { return fatalSimple(rc); } - + g_has_debug_events_thread = true; } } void DmntCheatManager::WaitDebugEventsThread() { std::scoped_lock lk(g_debug_event_thread_lock); - + /* Wait for the thread to exit. */ if (g_has_debug_events_thread) { g_debug_events_thread.CancelSynchronization(); g_debug_events_thread.Join(); - + g_has_debug_events_thread = false; } } @@ -83,14 +85,22 @@ void DmntCheatManager::CloseActiveCheatProcess() { /* Close process resources. */ svcCloseHandle(g_cheat_process_debug_hnd); g_cheat_process_debug_hnd = 0; + + /* Save cheat toggles. */ + if (g_always_save_cheat_toggles || g_should_save_cheat_toggles) { + SaveCheatToggles(g_cheat_process_metadata.title_id); + g_should_save_cheat_toggles = false; + } + + /* Clear metadata. */ g_cheat_process_metadata = (CheatProcessMetadata){0}; - + /* Clear cheat list. */ ResetAllCheatEntries(); - + /* Clear frozen addresses. */ ResetFrozenAddresses(); - + /* Signal to our fans. */ g_cheat_process_event->Signal(); } @@ -99,15 +109,15 @@ void DmntCheatManager::CloseActiveCheatProcess() { bool DmntCheatManager::HasActiveCheatProcess() { u64 tmp; bool has_cheat_process = g_cheat_process_debug_hnd != 0; - + if (has_cheat_process) { has_cheat_process &= R_SUCCEEDED(svcGetProcessId(&tmp, g_cheat_process_debug_hnd)); } - + if (has_cheat_process) { has_cheat_process &= R_SUCCEEDED(pmdmntGetApplicationPid(&tmp)); } - + if (has_cheat_process) { has_cheat_process &= tmp == g_cheat_process_metadata.process_id; } @@ -115,7 +125,7 @@ bool DmntCheatManager::HasActiveCheatProcess() { if (!has_cheat_process) { CloseActiveCheatProcess(); } - + return has_cheat_process; } @@ -123,14 +133,14 @@ Result DmntCheatManager::ReadCheatProcessMemoryForVm(u64 proc_addr, void *out_da if (HasActiveCheatProcess()) { return svcReadDebugProcessMemory(out_data, g_cheat_process_debug_hnd, proc_addr, size); } - + return ResultDmntCheatNotAttached; } Result DmntCheatManager::WriteCheatProcessMemoryForVm(u64 proc_addr, const void *data, size_t size) { if (HasActiveCheatProcess()) { Result rc = svcWriteDebugProcessMemory(g_cheat_process_debug_hnd, data, proc_addr, size); - + /* We might have a frozen address. Update it if we do! */ if (R_SUCCEEDED(rc)) { for (auto & [address, value] : g_frozen_addresses_map) { @@ -138,7 +148,7 @@ Result DmntCheatManager::WriteCheatProcessMemoryForVm(u64 proc_addr, const void if (address >= proc_addr + size) { break; } - + /* Check if we need to write. */ if (proc_addr <= address) { const size_t offset = (address - proc_addr); @@ -147,23 +157,23 @@ Result DmntCheatManager::WriteCheatProcessMemoryForVm(u64 proc_addr, const void } } } - + return rc; } - + return ResultDmntCheatNotAttached; } Result DmntCheatManager::GetCheatProcessMappingCount(u64 *out_count) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + MemoryInfo mem_info; - + u64 address = 0; *out_count = 0; do { @@ -172,24 +182,24 @@ Result DmntCheatManager::GetCheatProcessMappingCount(u64 *out_count) { if (R_FAILED(svcQueryDebugProcessMemory(&mem_info, &tmp, g_cheat_process_debug_hnd, address))) { break; } - + if (mem_info.perm != 0) { *out_count += 1; } - + address = mem_info.addr + mem_info.size; } while (address != 0); - + return 0; } Result DmntCheatManager::GetCheatProcessMappings(MemoryInfo *mappings, size_t max_count, u64 *out_count, u64 offset) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + MemoryInfo mem_info; u64 address = 0; u64 count = 0; @@ -200,40 +210,40 @@ Result DmntCheatManager::GetCheatProcessMappings(MemoryInfo *mappings, size_t ma if (R_FAILED(svcQueryDebugProcessMemory(&mem_info, &tmp, g_cheat_process_debug_hnd, address))) { break; } - + if (mem_info.perm != 0) { count++; if (count > offset) { mappings[(*out_count)++] = mem_info; } } - + address = mem_info.addr + mem_info.size; } while (address != 0 && *out_count < max_count); - + return 0; } Result DmntCheatManager::ReadCheatProcessMemory(u64 proc_addr, void *out_data, size_t size) { std::scoped_lock lk(g_cheat_lock); - + return ReadCheatProcessMemoryForVm(proc_addr, out_data, size); } Result DmntCheatManager::WriteCheatProcessMemory(u64 proc_addr, const void *data, size_t size) { std::scoped_lock lk(g_cheat_lock); - + return WriteCheatProcessMemoryForVm(proc_addr, data, size); } Result DmntCheatManager::QueryCheatProcessMemory(MemoryInfo *mapping, u64 address) { std::scoped_lock lk(g_cheat_lock); - + if (HasActiveCheatProcess()) { u32 tmp; return svcQueryDebugProcessMemory(mapping, &tmp, g_cheat_process_debug_hnd, address); } - + return ResultDmntCheatNotAttached; } @@ -247,7 +257,7 @@ void DmntCheatManager::ResetCheatEntry(size_t i) { g_cheat_entries[i].enabled = false; g_cheat_entries[i].cheat_id = i; g_cheat_entries[i].definition = {0}; - + /* Trigger a VM reload. */ g_needs_reload_vm_program = true; } @@ -266,7 +276,7 @@ CheatEntry *DmntCheatManager::GetFreeCheatEntry() { return &g_cheat_entries[i]; } } - + return nullptr; } @@ -274,17 +284,28 @@ CheatEntry *DmntCheatManager::GetCheatEntryById(size_t i) { if (i < DmntCheatManager::MaxCheatCount) { return &g_cheat_entries[i]; } - + + return nullptr; +} + +CheatEntry *DmntCheatManager::GetCheatEntryByReadableName(const char *readable_name) { + /* Check all non-master cheats for match. */ + for (size_t i = 1; i < DmntCheatManager::MaxCheatCount; i++) { + if (strcmp(g_cheat_entries[i].definition.readable_name, readable_name) == 0) { + return &g_cheat_entries[i]; + } + } + return nullptr; } bool DmntCheatManager::ParseCheats(const char *s, size_t len) { size_t i = 0; CheatEntry *cur_entry = NULL; - + /* Trigger a VM reload. */ g_needs_reload_vm_program = true; - + while (i < len) { if (isspace(s[i])) { /* Just ignore space. */ @@ -295,7 +316,7 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) { if (cur_entry == NULL) { return false; } - + /* Extract name bounds. */ size_t j = i + 1; while (s[j] != ']') { @@ -304,23 +325,23 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) { return false; } } - + /* s[i+1:j] is cheat name. */ const size_t cheat_name_len = (j - i - 1); memcpy(cur_entry->definition.readable_name, &s[i+1], cheat_name_len); cur_entry->definition.readable_name[cheat_name_len] = 0; - + /* Skip onwards. */ i = j + 1; } else if (s[i] == '{') { /* We're parsing a master cheat. */ cur_entry = &g_cheat_entries[0]; - + /* There can only be one master cheat. */ if (cur_entry->definition.num_opcodes > 0) { return false; } - + /* Extract name bounds */ size_t j = i + 1; while (s[j] != '}') { @@ -329,12 +350,12 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) { return false; } } - + /* s[i+1:j] is cheat name. */ const size_t cheat_name_len = (j - i - 1); memcpy(cur_entry->definition.readable_name, &s[i+1], cheat_name_len); cur_entry->definition.readable_name[cheat_name_len] = 0; - + /* Skip onwards. */ i = j + 1; } else if (isxdigit(s[i])) { @@ -342,12 +363,12 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) { if (cur_entry == NULL) { return false; } - + /* Bounds check the opcode count. */ if (cur_entry->definition.num_opcodes >= sizeof(cur_entry->definition.opcodes)/sizeof(cur_entry->definition.opcodes[0])) { return false; } - + /* We're parsing an instruction, so validate it's 8 hex digits. */ for (size_t j = 1; j < 8; j++) { /* Validate 8 hex chars. */ @@ -355,13 +376,13 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) { return false; } } - + /* Parse the new opcode. */ char hex_str[9] = {0}; memcpy(hex_str, &s[i], 8); cur_entry->definition.opcodes[cur_entry->definition.num_opcodes++] = strtoul(hex_str, NULL, 16); - - + + /* Skip onwards. */ i += 8; } else { @@ -369,88 +390,227 @@ bool DmntCheatManager::ParseCheats(const char *s, size_t len) { return false; } } - + /* Master cheat can't be disabled. */ if (g_cheat_entries[0].definition.num_opcodes > 0) { g_cheat_entries[0].enabled = true; } - + /* Enable all entries we parsed. */ for (size_t i = 1; i < DmntCheatManager::MaxCheatCount; i++) { if (g_cheat_entries[i].definition.num_opcodes > 0) { g_cheat_entries[i].enabled = g_enable_cheats_by_default; } } - + return true; } bool DmntCheatManager::LoadCheats(u64 title_id, const u8 *build_id) { /* Reset existing entries. */ ResetAllCheatEntries(); - + FILE *f_cht = NULL; /* Open the file for title/build_id. */ { char path[FS_MAX_PATH+1] = {0}; snprintf(path, FS_MAX_PATH, "sdmc:/atmosphere/titles/%016lx/cheats/%02x%02x%02x%02x%02x%02x%02x%02x.txt", title_id, - build_id[0], build_id[1], build_id[2], build_id[3], build_id[4], build_id[5], build_id[6], build_id[7]); + build_id[0], build_id[1], build_id[2], build_id[3], build_id[4], build_id[5], build_id[6], build_id[7]); f_cht = fopen(path, "rb"); } - + /* Check for NULL */ if (f_cht == NULL) { return false; } ON_SCOPE_EXIT { fclose(f_cht); }; - + /* Get file size. */ fseek(f_cht, 0L, SEEK_END); const size_t cht_sz = ftell(f_cht); fseek(f_cht, 0L, SEEK_SET); - + /* Allocate cheat txt buffer. */ char *cht_txt = (char *)malloc(cht_sz + 1); if (cht_txt == NULL) { return false; } ON_SCOPE_EXIT { free(cht_txt); }; - + /* Read cheats into buffer. */ if (fread(cht_txt, 1, cht_sz, f_cht) != cht_sz) { return false; } cht_txt[cht_sz] = 0; - + /* Parse cheat buffer. */ return ParseCheats(cht_txt, strlen(cht_txt)); } +bool DmntCheatManager::ParseCheatToggles(const char *s, size_t len) { + size_t i = 0; + char cur_cheat_name[sizeof(CheatEntry::definition.readable_name)]; + char toggle[8]; + + while (i < len) { + if (isspace(s[i])) { + /* Just ignore space. */ + i++; + } else if (s[i] == '[') { + + /* Extract name bounds. */ + size_t j = i + 1; + while (s[j] != ']') { + j++; + if (j >= len || (j - i - 1) >= sizeof(cur_cheat_name)) { + return false; + } + } + + /* s[i+1:j] is cheat name. */ + const size_t cheat_name_len = (j - i - 1); + memcpy(cur_cheat_name, &s[i+1], cheat_name_len); + cur_cheat_name[cheat_name_len] = 0; + + /* Skip onwards. */ + i = j + 1; + + /* Skip whitespace. */ + while (isspace(s[i])) { + i++; + } + + /* Parse whether to toggle. */ + j = i + 1; + while (!isspace(s[j])) { + j++; + if (j >= len || (j - i) >= sizeof(toggle)) { + return false; + } + } + + /* s[i:j] is toggle. */ + const size_t toggle_len = (j - i); + memcpy(toggle, &s[i], toggle_len); + toggle[toggle_len] = 0; + + /* Allow specifying toggle for not present cheat. */ + CheatEntry *entry = GetCheatEntryByReadableName(cur_cheat_name); + if (entry != nullptr) { + if (strcasecmp(toggle, "1") == 0 || strcasecmp(toggle, "true") == 0 || strcasecmp(toggle, "on") == 0) { + entry->enabled = true; + } else if (strcasecmp(toggle, "0") == 0 || strcasecmp(toggle, "false") == 0 || strcasecmp(toggle, "off") == 0) { + entry->enabled = false; + } + } + + /* Skip onwards. */ + i = j + 1; + } else { + /* Unexpected character encountered. */ + return false; + } + } + + return true; +} + +bool DmntCheatManager::LoadCheatToggles(u64 title_id) { + FILE *f_tg = NULL; + /* Open the file for title id. */ + { + char path[FS_MAX_PATH+1] = {0}; + snprintf(path, FS_MAX_PATH, "sdmc:/atmosphere/titles/%016lx/cheats/toggles.txt", title_id); + + f_tg = fopen(path, "rb"); + } + + /* Unless we successfully parse, don't save toggles on close. */ + g_should_save_cheat_toggles = false; + + /* Check for NULL, which is allowed. */ + if (f_tg == NULL) { + return true; + } + ON_SCOPE_EXIT { fclose(f_tg); }; + + /* Get file size. */ + fseek(f_tg, 0L, SEEK_END); + const size_t tg_sz = ftell(f_tg); + fseek(f_tg, 0L, SEEK_SET); + + /* Allocate toggle txt buffer. */ + char *tg_txt = (char *)malloc(tg_sz + 1); + if (tg_txt == NULL) { + return false; + } + ON_SCOPE_EXIT { free(tg_txt); }; + + /* Read toggles into buffer. */ + if (fread(tg_txt, 1, tg_sz, f_tg) != tg_sz) { + return false; + } + tg_txt[tg_sz] = 0; + + /* Parse toggle buffer. */ + g_should_save_cheat_toggles = ParseCheatToggles(tg_txt, strlen(tg_txt)); + return g_should_save_cheat_toggles; +} + +void DmntCheatManager::SaveCheatToggles(u64 title_id) { + FILE *f_tg = NULL; + /* Open the file for title id. */ + { + char path[FS_MAX_PATH+1] = {0}; + snprintf(path, FS_MAX_PATH, "sdmc:/atmosphere/titles/%016lx/cheats/toggles.txt", title_id); + + f_tg = fopen(path, "wb"); + } + + if (f_tg == NULL) { + return; + } + + ON_SCOPE_EXIT { fclose(f_tg); }; + + /* Save all non-master cheats. */ + for (size_t i = 1; i < DmntCheatManager::MaxCheatCount; i++) { + if (g_cheat_entries[i].definition.num_opcodes != 0) { + fprintf(f_tg, "[%s]\n", g_cheat_entries[i].definition.readable_name); + if (g_cheat_entries[i].enabled) { + fprintf(f_tg, "true\n"); + } else { + fprintf(f_tg, "false\n"); + } + } + } +} + Result DmntCheatManager::GetCheatCount(u64 *out_count) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + *out_count = 0; for (size_t i = 0; i < DmntCheatManager::MaxCheatCount; i++) { if (g_cheat_entries[i].definition.num_opcodes > 0) { *out_count += 1; } } - + return 0; } Result DmntCheatManager::GetCheats(CheatEntry *cheats, size_t max_count, u64 *out_count, u64 offset) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + u64 count = 0; *out_count = 0; for (size_t i = 0; i < DmntCheatManager::MaxCheatCount && (*out_count) < max_count; i++) { @@ -461,44 +621,44 @@ Result DmntCheatManager::GetCheats(CheatEntry *cheats, size_t max_count, u64 *ou } } } - + return 0; } Result DmntCheatManager::GetCheatById(CheatEntry *out_cheat, u32 cheat_id) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + const CheatEntry *entry = GetCheatEntryById(cheat_id); if (entry == nullptr || entry->definition.num_opcodes == 0) { return ResultDmntCheatUnknownChtId; } - + *out_cheat = *entry; return 0; } Result DmntCheatManager::ToggleCheat(u32 cheat_id) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + CheatEntry *entry = GetCheatEntryById(cheat_id); if (entry == nullptr || entry->definition.num_opcodes == 0) { return ResultDmntCheatUnknownChtId; } - + if (cheat_id == 0) { return ResultDmntCheatCannotDisableMasterCheat; } - + entry->enabled = !entry->enabled; - + /* Trigger a VM reload. */ g_needs_reload_vm_program = true; return 0; @@ -506,23 +666,23 @@ Result DmntCheatManager::ToggleCheat(u32 cheat_id) { Result DmntCheatManager::AddCheat(u32 *out_id, CheatDefinition *def, bool enabled) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + if (def->num_opcodes == 0 || def->num_opcodes > sizeof(def->opcodes)/sizeof(def->opcodes[0])) { return ResultDmntCheatInvalidCheat; } - + CheatEntry *new_entry = GetFreeCheatEntry(); if (new_entry == nullptr) { return ResultDmntCheatOutOfCheats; } - + new_entry->enabled = enabled; new_entry->definition = *def; - + /* Trigger a VM reload. */ g_needs_reload_vm_program = true; return 0; @@ -530,17 +690,17 @@ Result DmntCheatManager::AddCheat(u32 *out_id, CheatDefinition *def, bool enable Result DmntCheatManager::RemoveCheat(u32 cheat_id) { std::scoped_lock lk(g_cheat_lock); - + if (!HasActiveCheatProcess()) { return ResultDmntCheatNotAttached; } - + if (cheat_id >= DmntCheatManager::MaxCheatCount) { return ResultDmntCheatUnknownChtId; } - + ResetCheatEntry(cheat_id); - + /* Trigger a VM reload. */ g_needs_reload_vm_program = true; return 0; @@ -548,29 +708,29 @@ Result DmntCheatManager::RemoveCheat(u32 cheat_id) { Result DmntCheatManager::GetFrozenAddressCount(u64 *out_count) { std::scoped_lock 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 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)++; @@ -578,22 +738,22 @@ Result DmntCheatManager::GetFrozenAddresses(FrozenAddressEntry *frz_addrs, size_ frz_addrs[cur_ind].value = value; } } - + return 0; } Result DmntCheatManager::GetFrozenAddress(FrozenAddressEntry *frz_addr, u64 address) { std::scoped_lock 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; @@ -601,27 +761,27 @@ Result DmntCheatManager::GetFrozenAddress(FrozenAddressEntry *frz_addr, u64 add Result DmntCheatManager::EnableFrozenAddress(u64 *out_value, u64 address, u64 width) { std::scoped_lock 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; *out_value = value.value; return 0; @@ -629,16 +789,16 @@ Result DmntCheatManager::EnableFrozenAddress(u64 *out_value, u64 address, u64 wi Result DmntCheatManager::DisableFrozenAddress(u64 address) { std::scoped_lock 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; } @@ -649,7 +809,7 @@ Handle DmntCheatManager::PrepareDebugNextApplication() { if (R_FAILED((rc = pmdmntEnableDebugForApplication(&event_h)))) { fatalSimple(rc); } - + return event_h; } @@ -659,7 +819,7 @@ static void PopulateMemoryExtents(MemoryRegionExtents *extents, Handle p_h, u64 if (R_FAILED((rc = svcGetInfo(&extents->base, id_base, p_h, 0)))) { fatalSimple(rc); } - + /* Get size extent. */ if (R_FAILED((rc = svcGetInfo(&extents->size, id_size, p_h, 0)))) { fatalSimple(rc); @@ -676,41 +836,41 @@ static void StartDebugProcess(u64 pid) { Result DmntCheatManager::ForceOpenCheatProcess() { std::scoped_lock attach_lk(g_attach_lock); Result rc; - + /* Acquire the cheat lock for long enough to close the process if needed. */ { std::scoped_lock lk(g_cheat_lock); - + if (HasActiveCheatProcess()) { return 0; } - + /* Close the current application, if it's open. */ CloseActiveCheatProcess(); } - + /* Intentionally yield the cheat lock to the debug events thread. */ /* Wait to not have debug events thread. */ WaitDebugEventsThread(); - + /* At this point, we can re-acquire the lock for the rest of the function. */ std::scoped_lock lk(g_cheat_lock); - + /* Get the current application process ID. */ if (R_FAILED((rc = pmdmntGetApplicationPid(&g_cheat_process_metadata.process_id)))) { return rc; } ON_SCOPE_EXIT { if (R_FAILED(rc)) { g_cheat_process_metadata.process_id = 0; } }; - + /* Get process handle, use it to learn memory extents. */ { Handle proc_h = 0; ON_SCOPE_EXIT { if (proc_h != 0) { svcCloseHandle(proc_h); } }; - + if (R_FAILED((rc = pmdmntAtmosphereGetProcessInfo(&proc_h, &g_cheat_process_metadata.title_id, nullptr, g_cheat_process_metadata.process_id)))) { return rc; } - + /* Get memory extents. */ PopulateMemoryExtents(&g_cheat_process_metadata.heap_extents, proc_h, 4, 5); PopulateMemoryExtents(&g_cheat_process_metadata.alias_extents, proc_h, 2, 3); @@ -721,7 +881,7 @@ Result DmntCheatManager::ForceOpenCheatProcess() { g_cheat_process_metadata.address_space_extents.size = 0x78000000UL; } } - + /* Get module information from Loader. */ { LoaderModuleInfo proc_modules[2]; @@ -729,7 +889,7 @@ Result DmntCheatManager::ForceOpenCheatProcess() { if (R_FAILED((rc = ldrDmntGetModuleInfos(g_cheat_process_metadata.process_id, proc_modules, sizeof(proc_modules), &num_modules)))) { return rc; } - + /* All applications must have two modules. */ /* However, this is a force-open, so we will accept one module. */ /* Poor HBL, I guess... */ @@ -742,60 +902,63 @@ Result DmntCheatManager::ForceOpenCheatProcess() { rc = ResultDmntCheatNotAttached; return rc; } - + g_cheat_process_metadata.main_nso_extents.base = proc_module->base_address; g_cheat_process_metadata.main_nso_extents.size = proc_module->size; memcpy(g_cheat_process_metadata.main_nso_build_id, proc_module->build_id, sizeof(g_cheat_process_metadata.main_nso_build_id)); } - + /* Read cheats off the SD. */ /* This is allowed to fail. We may not have any cheats. */ LoadCheats(g_cheat_process_metadata.title_id, g_cheat_process_metadata.main_nso_build_id); - + + /* Load saved toggles, if present. */ + LoadCheatToggles(g_cheat_process_metadata.title_id); + /* Open a debug handle. */ if (R_FAILED((rc = svcDebugActiveProcess(&g_cheat_process_debug_hnd, g_cheat_process_metadata.process_id)))) { return rc; } /* Start debug events thread. */ StartDebugEventsThread(); - + /* Signal to our fans. */ g_cheat_process_event->Signal(); - + return rc; } void DmntCheatManager::OnNewApplicationLaunch() { std::scoped_lock attach_lk(g_attach_lock); Result rc; - + { std::scoped_lock lk(g_cheat_lock); /* Close the current application, if it's open. */ CloseActiveCheatProcess(); } - + /* Intentionally yield the cheat lock to the debug events thread. */ /* Wait to not have debug events thread. */ WaitDebugEventsThread(); - + /* At this point, we can re-acquire the lock for the rest of the function. */ std::scoped_lock lk(g_cheat_lock); - + /* Get the new application's process ID. */ if (R_FAILED((rc = pmdmntGetApplicationPid(&g_cheat_process_metadata.process_id)))) { fatalSimple(rc); } - + /* Get process handle, use it to learn memory extents. */ { Handle proc_h = 0; ON_SCOPE_EXIT { if (proc_h != 0) { svcCloseHandle(proc_h); } }; - + if (R_FAILED((rc = pmdmntAtmosphereGetProcessInfo(&proc_h, &g_cheat_process_metadata.title_id, nullptr, g_cheat_process_metadata.process_id)))) { fatalSimple(rc); } - + /* Get memory extents. */ PopulateMemoryExtents(&g_cheat_process_metadata.heap_extents, proc_h, 4, 5); PopulateMemoryExtents(&g_cheat_process_metadata.alias_extents, proc_h, 2, 3); @@ -806,14 +969,14 @@ void DmntCheatManager::OnNewApplicationLaunch() { g_cheat_process_metadata.address_space_extents.size = 0x78000000UL; } } - + /* Check if we should skip based on keys down. */ if (!DmntConfigManager::HasCheatEnableButton(g_cheat_process_metadata.title_id)) { StartDebugProcess(g_cheat_process_metadata.process_id); g_cheat_process_metadata.process_id = 0; return; } - + /* Get module information from Loader. */ { LoaderModuleInfo proc_modules[2]; @@ -821,7 +984,7 @@ void DmntCheatManager::OnNewApplicationLaunch() { if (R_FAILED((rc = ldrDmntGetModuleInfos(g_cheat_process_metadata.process_id, proc_modules, sizeof(proc_modules), &num_modules)))) { fatalSimple(rc); } - + /* All applications must have two modules. */ /* If we only have one, we must be e.g. mitming HBL. */ /* We don't want to fuck with HBL. */ @@ -830,31 +993,31 @@ void DmntCheatManager::OnNewApplicationLaunch() { g_cheat_process_metadata.process_id = 0; return; } - + g_cheat_process_metadata.main_nso_extents.base = proc_modules[1].base_address; g_cheat_process_metadata.main_nso_extents.size = proc_modules[1].size; memcpy(g_cheat_process_metadata.main_nso_build_id, proc_modules[1].build_id, sizeof(g_cheat_process_metadata.main_nso_build_id)); } - + /* Read cheats off the SD. */ - if (!LoadCheats(g_cheat_process_metadata.title_id, g_cheat_process_metadata.main_nso_build_id)) { + if (!LoadCheats(g_cheat_process_metadata.title_id, g_cheat_process_metadata.main_nso_build_id) || !LoadCheatToggles(g_cheat_process_metadata.title_id)) { /* If we don't have cheats, or cheats are malformed, don't attach. */ StartDebugProcess(g_cheat_process_metadata.process_id); g_cheat_process_metadata.process_id = 0; return; } - + /* Open a debug handle. */ if (R_FAILED((rc = svcDebugActiveProcess(&g_cheat_process_debug_hnd, g_cheat_process_metadata.process_id)))) { fatalSimple(rc); } - + /* Start the process. */ StartDebugProcess(g_cheat_process_metadata.process_id); /* Start debug events thread. */ StartDebugEventsThread(); - + /* Signal to our fans. */ g_cheat_process_event->Signal(); } @@ -864,43 +1027,43 @@ void DmntCheatManager::DetectThread(void *arg) { waiter->AddWaitable(LoadReadOnlySystemEvent(PrepareDebugNextApplication(), [](u64 timeout) { /* Process stuff for new application. */ DmntCheatManager::OnNewApplicationLaunch(); - + /* Setup detection for the next application, and close the duplicate handle. */ svcCloseHandle(PrepareDebugNextApplication()); - + return 0x0; }, true)); - + waiter->Process(); delete waiter; } - + void DmntCheatManager::VmThread(void *arg) { while (true) { /* Execute Cheat VM. */ { /* Acquire lock. */ std::scoped_lock lk(g_cheat_lock); - + if (HasActiveCheatProcess()) { /* Execute VM. */ if (!g_needs_reload_vm_program || (g_cheat_vm->LoadProgram(g_cheat_entries, DmntCheatManager::MaxCheatCount))) { /* Program: reloaded. */ g_needs_reload_vm_program = false; - + /* Execute program if it's present. */ if (g_cheat_vm->GetProgramSize() != 0) { 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); } } } - + constexpr u64 ONE_SECOND = 1000000000ul; constexpr u64 NUM_TIMES = 12; constexpr u64 DELAY = ONE_SECOND / NUM_TIMES; @@ -909,21 +1072,21 @@ void DmntCheatManager::VmThread(void *arg) { } void DmntCheatManager::DebugEventsThread(void *arg) { - - while (R_SUCCEEDED(svcWaitSynchronizationSingle(g_cheat_process_debug_hnd, U64_MAX))) { + + while (R_SUCCEEDED(svcWaitSynchronizationSingle(g_cheat_process_debug_hnd, U64_MAX))) { std::scoped_lock lk(g_cheat_lock); - + /* Handle any pending debug events. */ if (HasActiveCheatProcess()) { DmntCheatDebugEventsManager::ContinueCheatProcess(g_cheat_process_debug_hnd); } - + } } bool DmntCheatManager::GetHasActiveCheatProcess() { std::scoped_lock lk(g_cheat_lock); - + return HasActiveCheatProcess(); } @@ -933,42 +1096,46 @@ Handle DmntCheatManager::GetCheatProcessEventHandle() { Result DmntCheatManager::GetCheatProcessMetadata(CheatProcessMetadata *out) { std::scoped_lock lk(g_cheat_lock); - + if (HasActiveCheatProcess()) { *out = g_cheat_process_metadata; return 0; } - + return ResultDmntCheatNotAttached; } void DmntCheatManager::InitializeCheatManager() { /* Create cheat process detection event. */ g_cheat_process_event = CreateWriteOnlySystemEvent(); - + /* Create cheat vm. */ g_cheat_vm = new DmntCheatVm(); - + /* Learn whether we should enable cheats by default. */ { u8 en; if (R_SUCCEEDED(setsysGetSettingsItemValue("atmosphere", "dmnt_cheats_enabled_by_default", &en, sizeof(en)))) { g_enable_cheats_by_default = (en != 0); } + + if (R_SUCCEEDED(setsysGetSettingsItemValue("atmosphere", "dmnt_always_save_cheat_toggles", &en, sizeof(en)))) { + g_always_save_cheat_toggles = (en != 0); + } } - + /* Initialize debug events manager. */ DmntCheatDebugEventsManager::Initialize(); - + /* Spawn application detection thread, spawn cheat vm thread. */ if (R_FAILED(g_detect_thread.Initialize(&DmntCheatManager::DetectThread, nullptr, 0x4000, 39))) { std::abort(); } - + if (R_FAILED(g_vm_thread.Initialize(&DmntCheatManager::VmThread, nullptr, 0x4000, 48))) { std::abort(); } - + /* Start threads. */ if (R_FAILED(g_detect_thread.Start()) || R_FAILED(g_vm_thread.Start())) { std::abort(); diff --git a/stratosphere/dmnt/source/dmnt_cheat_manager.hpp b/stratosphere/dmnt/source/dmnt_cheat_manager.hpp index dc8bff712..0805e52e4 100644 --- a/stratosphere/dmnt/source/dmnt_cheat_manager.hpp +++ b/stratosphere/dmnt/source/dmnt_cheat_manager.hpp @@ -42,8 +42,13 @@ class DmntCheatManager { static void ResetAllCheatEntries(); static CheatEntry *GetFreeCheatEntry(); static CheatEntry *GetCheatEntryById(size_t i); + static CheatEntry *GetCheatEntryByReadableName(const char *readable_name); static bool ParseCheats(const char *cht_txt, size_t len); static bool LoadCheats(u64 title_id, const u8 *build_id); + + static bool ParseCheatToggles(const char *s, size_t len); + static bool LoadCheatToggles(u64 title_id); + static void SaveCheatToggles(u64 title_id); static void ResetFrozenAddresses(); public: