summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/audio_core/audio_renderer.cpp89
-rw-r--r--src/audio_core/audio_renderer.h49
-rw-r--r--src/common/hex_util.cpp19
-rw-r--r--src/common/hex_util.h5
-rw-r--r--src/core/file_sys/fsmitm_romfsbuild.cpp26
-rw-r--r--src/core/file_sys/fsmitm_romfsbuild.h6
-rw-r--r--src/core/file_sys/ips_layer.cpp266
-rw-r--r--src/core/file_sys/ips_layer.h29
-rw-r--r--src/core/file_sys/patch_manager.cpp92
-rw-r--r--src/core/file_sys/patch_manager.h1
-rw-r--r--src/core/file_sys/romfs.cpp4
-rw-r--r--src/core/file_sys/romfs.h2
-rw-r--r--src/core/telemetry_session.cpp12
-rw-r--r--src/core/telemetry_session.h4
14 files changed, 541 insertions, 63 deletions
diff --git a/src/audio_core/audio_renderer.cpp b/src/audio_core/audio_renderer.cpp
index 6f0ff953a..23e5d3f10 100644
--- a/src/audio_core/audio_renderer.cpp
+++ b/src/audio_core/audio_renderer.cpp
@@ -30,7 +30,7 @@ public:
return info;
}
- VoiceInfo& Info() {
+ VoiceInfo& GetInfo() {
return info;
}
@@ -51,9 +51,30 @@ private:
VoiceInfo info{};
};
+class AudioRenderer::EffectState {
+public:
+ const EffectOutStatus& GetOutStatus() const {
+ return out_status;
+ }
+
+ const EffectInStatus& GetInfo() const {
+ return info;
+ }
+
+ EffectInStatus& GetInfo() {
+ return info;
+ }
+
+ void UpdateState();
+
+private:
+ EffectOutStatus out_status{};
+ EffectInStatus info{};
+};
AudioRenderer::AudioRenderer(AudioRendererParameter params,
Kernel::SharedPtr<Kernel::Event> buffer_event)
- : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count) {
+ : worker_params{params}, buffer_event{buffer_event}, voices(params.voice_count),
+ effects(params.effect_count) {
audio_out = std::make_unique<AudioCore::AudioOut>();
stream = audio_out->OpenStream(STREAM_SAMPLE_RATE, STREAM_NUM_CHANNELS, "AudioRenderer",
@@ -96,11 +117,29 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
memory_pool_count * sizeof(MemoryPoolInfo));
// Copy VoiceInfo structs
- std::size_t offset{sizeof(UpdateDataHeader) + config.behavior_size + config.memory_pools_size +
- config.voice_resource_size};
+ std::size_t voice_offset{sizeof(UpdateDataHeader) + config.behavior_size +
+ config.memory_pools_size + config.voice_resource_size};
for (auto& voice : voices) {
- std::memcpy(&voice.Info(), input_params.data() + offset, sizeof(VoiceInfo));
- offset += sizeof(VoiceInfo);
+ std::memcpy(&voice.GetInfo(), input_params.data() + voice_offset, sizeof(VoiceInfo));
+ voice_offset += sizeof(VoiceInfo);
+ }
+
+ std::size_t effect_offset{sizeof(UpdateDataHeader) + config.behavior_size +
+ config.memory_pools_size + config.voice_resource_size +
+ config.voices_size};
+ for (auto& effect : effects) {
+ std::memcpy(&effect.GetInfo(), input_params.data() + effect_offset, sizeof(EffectInStatus));
+ effect_offset += sizeof(EffectInStatus);
+ }
+
+ // Update memory pool state
+ std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
+ for (std::size_t index = 0; index < memory_pool.size(); ++index) {
+ if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestAttach) {
+ memory_pool[index].state = MemoryPoolStates::Attached;
+ } else if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestDetach) {
+ memory_pool[index].state = MemoryPoolStates::Detached;
+ }
}
// Update voices
@@ -114,14 +153,8 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
}
}
- // Update memory pool state
- std::vector<MemoryPoolEntry> memory_pool(memory_pool_count);
- for (std::size_t index = 0; index < memory_pool.size(); ++index) {
- if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestAttach) {
- memory_pool[index].state = MemoryPoolStates::Attached;
- } else if (mem_pool_info[index].pool_state == MemoryPoolStates::RequestDetach) {
- memory_pool[index].state = MemoryPoolStates::Detached;
- }
+ for (auto& effect : effects) {
+ effect.UpdateState();
}
// Release previous buffers and queue next ones for playback
@@ -144,6 +177,14 @@ std::vector<u8> AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_
voice_out_status_offset += sizeof(VoiceOutStatus);
}
+ std::size_t effect_out_status_offset{
+ sizeof(UpdateDataHeader) + response_data.memory_pools_size + response_data.voices_size +
+ response_data.voice_resource_size};
+ for (const auto& effect : effects) {
+ std::memcpy(output_params.data() + effect_out_status_offset, &effect.GetOutStatus(),
+ sizeof(EffectOutStatus));
+ effect_out_status_offset += sizeof(EffectOutStatus);
+ }
return output_params;
}
@@ -244,11 +285,29 @@ void AudioRenderer::VoiceState::RefreshBuffer() {
break;
}
- samples = Interpolate(interp_state, std::move(samples), Info().sample_rate, STREAM_SAMPLE_RATE);
+ samples =
+ Interpolate(interp_state, std::move(samples), GetInfo().sample_rate, STREAM_SAMPLE_RATE);
is_refresh_pending = false;
}
+void AudioRenderer::EffectState::UpdateState() {
+ if (info.is_new) {
+ out_status.state = EffectStatus::New;
+ } else {
+ if (info.type == Effect::Aux) {
+ ASSERT_MSG(Memory::Read32(info.aux_info.return_buffer_info) == 0,
+ "Aux buffers tried to update");
+ ASSERT_MSG(Memory::Read32(info.aux_info.send_buffer_info) == 0,
+ "Aux buffers tried to update");
+ ASSERT_MSG(Memory::Read32(info.aux_info.return_buffer_base) == 0,
+ "Aux buffers tried to update");
+ ASSERT_MSG(Memory::Read32(info.aux_info.send_buffer_base) == 0,
+ "Aux buffers tried to update");
+ }
+ }
+}
+
static constexpr s16 ClampToS16(s32 value) {
return static_cast<s16>(std::clamp(value, -32768, 32767));
}
diff --git a/src/audio_core/audio_renderer.h b/src/audio_core/audio_renderer.h
index dfef89e1d..046417da3 100644
--- a/src/audio_core/audio_renderer.h
+++ b/src/audio_core/audio_renderer.h
@@ -28,6 +28,16 @@ enum class PlayState : u8 {
Paused = 2,
};
+enum class Effect : u8 {
+ None = 0,
+ Aux = 2,
+};
+
+enum class EffectStatus : u8 {
+ None = 0,
+ New = 1,
+};
+
struct AudioRendererParameter {
u32_le sample_rate;
u32_le sample_count;
@@ -128,6 +138,43 @@ struct VoiceOutStatus {
};
static_assert(sizeof(VoiceOutStatus) == 0x10, "VoiceOutStatus has wrong size");
+struct AuxInfo {
+ std::array<u8, 24> input_mix_buffers;
+ std::array<u8, 24> output_mix_buffers;
+ u32_le mix_buffer_count;
+ u32_le sample_rate; // Stored in the aux buffer currently
+ u32_le sampe_count;
+ u64_le send_buffer_info;
+ u64_le send_buffer_base;
+
+ u64_le return_buffer_info;
+ u64_le return_buffer_base;
+};
+static_assert(sizeof(AuxInfo) == 0x60, "AuxInfo is an invalid size");
+
+struct EffectInStatus {
+ Effect type;
+ u8 is_new;
+ u8 is_enabled;
+ INSERT_PADDING_BYTES(1);
+ u32_le mix_id;
+ u64_le buffer_base;
+ u64_le buffer_sz;
+ s32_le priority;
+ INSERT_PADDING_BYTES(4);
+ union {
+ std::array<u8, 0xa0> raw;
+ AuxInfo aux_info;
+ };
+};
+static_assert(sizeof(EffectInStatus) == 0xc0, "EffectInStatus is an invalid size");
+
+struct EffectOutStatus {
+ EffectStatus state;
+ INSERT_PADDING_BYTES(0xf);
+};
+static_assert(sizeof(EffectOutStatus) == 0x10, "EffectOutStatus is an invalid size");
+
struct UpdateDataHeader {
UpdateDataHeader() {}
@@ -173,11 +220,13 @@ public:
Stream::State GetStreamState() const;
private:
+ class EffectState;
class VoiceState;
AudioRendererParameter worker_params;
Kernel::SharedPtr<Kernel::Event> buffer_event;
std::vector<VoiceState> voices;
+ std::vector<EffectState> effects;
std::unique_ptr<AudioOut> audio_out;
AudioCore::StreamPtr stream;
};
diff --git a/src/common/hex_util.cpp b/src/common/hex_util.cpp
index 589ae5cbf..5b63f9e81 100644
--- a/src/common/hex_util.cpp
+++ b/src/common/hex_util.cpp
@@ -18,6 +18,25 @@ u8 ToHexNibble(char c1) {
return 0;
}
+std::vector<u8> HexStringToVector(std::string_view str, bool little_endian) {
+ std::vector<u8> out(str.size() / 2);
+ if (little_endian) {
+ for (std::size_t i = str.size() - 2; i <= str.size(); i -= 2)
+ out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
+ } else {
+ for (std::size_t i = 0; i < str.size(); i += 2)
+ out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
+ }
+ return out;
+}
+
+std::string HexVectorToString(const std::vector<u8>& vector, bool upper) {
+ std::string out;
+ for (u8 c : vector)
+ out += fmt::format(upper ? "{:02X}" : "{:02x}", c);
+ return out;
+}
+
std::array<u8, 16> operator""_array16(const char* str, std::size_t len) {
if (len != 32) {
LOG_ERROR(Common,
diff --git a/src/common/hex_util.h b/src/common/hex_util.h
index 863a5ccd9..68f003cb6 100644
--- a/src/common/hex_util.h
+++ b/src/common/hex_util.h
@@ -7,6 +7,7 @@
#include <array>
#include <cstddef>
#include <string>
+#include <vector>
#include <fmt/format.h>
#include "common/common_types.h"
@@ -14,6 +15,8 @@ namespace Common {
u8 ToHexNibble(char c1);
+std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
+
template <std::size_t Size, bool le = false>
std::array<u8, Size> HexStringToArray(std::string_view str) {
std::array<u8, Size> out{};
@@ -27,6 +30,8 @@ std::array<u8, Size> HexStringToArray(std::string_view str) {
return out;
}
+std::string HexVectorToString(const std::vector<u8>& vector, bool upper = true);
+
template <std::size_t Size>
std::string HexArrayToString(std::array<u8, Size> array, bool upper = true) {
std::string out;
diff --git a/src/core/file_sys/fsmitm_romfsbuild.cpp b/src/core/file_sys/fsmitm_romfsbuild.cpp
index 2a913ce82..47b7526c7 100644
--- a/src/core/file_sys/fsmitm_romfsbuild.cpp
+++ b/src/core/file_sys/fsmitm_romfsbuild.cpp
@@ -26,6 +26,7 @@
#include "common/alignment.h"
#include "common/assert.h"
#include "core/file_sys/fsmitm_romfsbuild.h"
+#include "core/file_sys/ips_layer.h"
#include "core/file_sys/vfs.h"
#include "core/file_sys/vfs_vector.h"
@@ -123,7 +124,7 @@ static u64 romfs_get_hash_table_count(u64 num_entries) {
return count;
}
-void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs,
+void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs, VirtualDir ext,
std::shared_ptr<RomFSBuildDirectoryContext> parent) {
std::vector<std::shared_ptr<RomFSBuildDirectoryContext>> child_dirs;
@@ -144,6 +145,9 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs,
child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
child->path = parent->path + "/" + kv.first;
+ if (ext != nullptr && ext->GetFileRelative(child->path + ".stub") != nullptr)
+ continue;
+
// Sanity check on path_len
ASSERT(child->path_len < FS_MAX_PATH);
@@ -157,11 +161,24 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs,
child->path_len = child->cur_path_ofs + static_cast<u32>(kv.first.size());
child->path = parent->path + "/" + kv.first;
+ if (ext != nullptr && ext->GetFileRelative(child->path + ".stub") != nullptr)
+ continue;
+
// Sanity check on path_len
ASSERT(child->path_len < FS_MAX_PATH);
child->source = root_romfs->GetFileRelative(child->path);
+ if (ext != nullptr) {
+ const auto ips = ext->GetFileRelative(child->path + ".ips");
+
+ if (ips != nullptr) {
+ auto patched = PatchIPS(child->source, ips);
+ if (patched != nullptr)
+ child->source = std::move(patched);
+ }
+ }
+
child->size = child->source->GetSize();
AddFile(parent, child);
@@ -169,7 +186,7 @@ void RomFSBuildContext::VisitDirectory(VirtualDir root_romfs,
}
for (auto& child : child_dirs) {
- this->VisitDirectory(root_romfs, child);
+ this->VisitDirectory(root_romfs, ext, child);
}
}
@@ -208,14 +225,15 @@ bool RomFSBuildContext::AddFile(std::shared_ptr<RomFSBuildDirectoryContext> pare
return true;
}
-RomFSBuildContext::RomFSBuildContext(VirtualDir base_) : base(std::move(base_)) {
+RomFSBuildContext::RomFSBuildContext(VirtualDir base_, VirtualDir ext_)
+ : base(std::move(base_)), ext(std::move(ext_)) {
root = std::make_shared<RomFSBuildDirectoryContext>();
root->path = "\0";
directories.emplace(root->path, root);
num_dirs = 1;
dir_table_size = 0x18;
- VisitDirectory(base, root);
+ VisitDirectory(base, ext, root);
}
RomFSBuildContext::~RomFSBuildContext() = default;
diff --git a/src/core/file_sys/fsmitm_romfsbuild.h b/src/core/file_sys/fsmitm_romfsbuild.h
index b0c3c123b..3d377b0af 100644
--- a/src/core/file_sys/fsmitm_romfsbuild.h
+++ b/src/core/file_sys/fsmitm_romfsbuild.h
@@ -40,7 +40,7 @@ struct RomFSFileEntry;
class RomFSBuildContext {
public:
- explicit RomFSBuildContext(VirtualDir base);
+ explicit RomFSBuildContext(VirtualDir base, VirtualDir ext = nullptr);
~RomFSBuildContext();
// This finalizes the context.
@@ -48,6 +48,7 @@ public:
private:
VirtualDir base;
+ VirtualDir ext;
std::shared_ptr<RomFSBuildDirectoryContext> root;
std::map<std::string, std::shared_ptr<RomFSBuildDirectoryContext>, std::less<>> directories;
std::map<std::string, std::shared_ptr<RomFSBuildFileContext>, std::less<>> files;
@@ -59,7 +60,8 @@ private:
u64 file_hash_table_size = 0;
u64 file_partition_size = 0;
- void VisitDirectory(VirtualDir filesys, std::shared_ptr<RomFSBuildDirectoryContext> parent);
+ void VisitDirectory(VirtualDir filesys, VirtualDir ext,
+ std::shared_ptr<RomFSBuildDirectoryContext> parent);
bool AddDirectory(std::shared_ptr<RomFSBuildDirectoryContext> parent_dir_ctx,
std::shared_ptr<RomFSBuildDirectoryContext> dir_ctx);
diff --git a/src/core/file_sys/ips_layer.cpp b/src/core/file_sys/ips_layer.cpp
index df933ee36..6c072d0a3 100644
--- a/src/core/file_sys/ips_layer.cpp
+++ b/src/core/file_sys/ips_layer.cpp
@@ -2,7 +2,15 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
-#include "common/assert.h"
+#include <algorithm>
+#include <cstring>
+#include <map>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "common/hex_util.h"
+#include "common/logging/log.h"
#include "common/swap.h"
#include "core/file_sys/ips_layer.h"
#include "core/file_sys/vfs_vector.h"
@@ -15,16 +23,48 @@ enum class IPSFileType {
Error,
};
+constexpr std::array<std::pair<const char*, const char*>, 11> ESCAPE_CHARACTER_MAP{{
+ {"\\a", "\a"},
+ {"\\b", "\b"},
+ {"\\f", "\f"},
+ {"\\n", "\n"},
+ {"\\r", "\r"},
+ {"\\t", "\t"},
+ {"\\v", "\v"},
+ {"\\\\", "\\"},
+ {"\\\'", "\'"},
+ {"\\\"", "\""},
+ {"\\\?", "\?"},
+}};
+
static IPSFileType IdentifyMagic(const std::vector<u8>& magic) {
- if (magic.size() != 5)
+ if (magic.size() != 5) {
return IPSFileType::Error;
- if (magic == std::vector<u8>{'P', 'A', 'T', 'C', 'H'})
+ }
+
+ constexpr std::array<u8, 5> patch_magic{{'P', 'A', 'T', 'C', 'H'}};
+ if (std::equal(magic.begin(), magic.end(), patch_magic.begin())) {
return IPSFileType::IPS;
- if (magic == std::vector<u8>{'I', 'P', 'S', '3', '2'})
+ }
+
+ constexpr std::array<u8, 5> ips32_magic{{'I', 'P', 'S', '3', '2'}};
+ if (std::equal(magic.begin(), magic.end(), ips32_magic.begin())) {
return IPSFileType::IPS32;
+ }
+
return IPSFileType::Error;
}
+static bool IsEOF(IPSFileType type, const std::vector<u8>& data) {
+ constexpr std::array<u8, 3> eof{{'E', 'O', 'F'}};
+ if (type == IPSFileType::IPS && std::equal(data.begin(), data.end(), eof.begin())) {
+ return true;
+ }
+
+ constexpr std::array<u8, 4> eeof{{'E', 'E', 'O', 'F'}};
+ return type == IPSFileType::IPS32 && std::equal(data.begin(), data.end(), eeof.begin());
+}
+
VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
if (in == nullptr || ips == nullptr)
return nullptr;
@@ -39,8 +79,7 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
u64 offset = 5; // After header
while (ips->Read(temp.data(), temp.size(), offset) == temp.size()) {
offset += temp.size();
- if (type == IPSFileType::IPS32 && temp == std::vector<u8>{'E', 'E', 'O', 'F'} ||
- type == IPSFileType::IPS && temp == std::vector<u8>{'E', 'O', 'F'}) {
+ if (IsEOF(type, temp)) {
break;
}
@@ -80,9 +119,220 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
}
}
- if (temp != std::vector<u8>{'E', 'E', 'O', 'F'} && temp != std::vector<u8>{'E', 'O', 'F'})
+ if (!IsEOF(type, temp)) {
return nullptr;
- return std::make_shared<VectorVfsFile>(in_data, in->GetName(), in->GetContainingDirectory());
+ }
+
+ return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
+ in->GetContainingDirectory());
+}
+
+struct IPSwitchCompiler::IPSwitchPatch {
+ std::string name;
+ bool enabled;
+ std::map<u32, std::vector<u8>> records;
+};
+
+IPSwitchCompiler::IPSwitchCompiler(VirtualFile patch_text_) : patch_text(std::move(patch_text_)) {
+ Parse();
+}
+
+IPSwitchCompiler::~IPSwitchCompiler() = default;
+
+std::array<u8, 32> IPSwitchCompiler::GetBuildID() const {
+ return nso_build_id;
+}
+
+bool IPSwitchCompiler::IsValid() const {
+ return valid;
+}
+
+static bool StartsWith(std::string_view base, std::string_view check) {
+ return base.size() >= check.size() && base.substr(0, check.size()) == check;
+}
+
+static std::string EscapeStringSequences(std::string in) {
+ for (const auto& seq : ESCAPE_CHARACTER_MAP) {
+ for (auto index = in.find(seq.first); index != std::string::npos;
+ index = in.find(seq.first, index)) {
+ in.replace(index, std::strlen(seq.first), seq.second);
+ index += std::strlen(seq.second);
+ }
+ }
+
+ return in;
+}
+
+void IPSwitchCompiler::ParseFlag(const std::string& line) {
+ if (StartsWith(line, "@flag offset_shift ")) {
+ // Offset Shift Flag
+ offset_shift = std::stoll(line.substr(19), nullptr, 0);
+ } else if (StartsWith(line, "@little-endian")) {
+ // Set values to read as little endian
+ is_little_endian = true;
+ } else if (StartsWith(line, "@big-endian")) {
+ // Set values to read as big endian
+ is_little_endian = false;
+ } else if (StartsWith(line, "@flag print_values")) {
+ // Force printing of applied values
+ print_values = true;
+ }
+}
+
+void IPSwitchCompiler::Parse() {
+ const auto bytes = patch_text->ReadAllBytes();
+ std::stringstream s;
+ s.write(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+
+ std::vector<std::string> lines;
+ std::string stream_line;
+ while (std::getline(s, stream_line)) {
+ // Remove a trailing \r
+ if (!stream_line.empty() && stream_line.back() == '\r')
+ stream_line.pop_back();
+ lines.push_back(std::move(stream_line));
+ }
+
+ for (std::size_t i = 0; i < lines.size(); ++i) {
+ auto line = lines[i];
+
+ // Remove midline comments
+ std::size_t comment_index = std::string::npos;
+ bool within_string = false;
+ for (std::size_t k = 0; k < line.size(); ++k) {
+ if (line[k] == '\"' && (k > 0 && line[k - 1] != '\\')) {
+ within_string = !within_string;
+ } else if (line[k] == '\\' && (k < line.size() - 1 && line[k + 1] == '\\')) {
+ comment_index = k;
+ break;
+ }
+ }
+
+ if (!StartsWith(line, "//") && comment_index != std::string::npos) {
+ last_comment = line.substr(comment_index + 2);
+ line = line.substr(0, comment_index);
+ }
+
+ if (StartsWith(line, "@stop")) {
+ // Force stop
+ break;
+ } else if (StartsWith(line, "@nsobid-")) {
+ // NSO Build ID Specifier
+ auto raw_build_id = line.substr(8);
+ if (raw_build_id.size() != 0x40)
+ raw_build_id.resize(0x40, '0');
+ nso_build_id = Common::HexStringToArray<0x20>(raw_build_id);
+ } else if (StartsWith(line, "#")) {
+ // Mandatory Comment
+ LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Forced output comment: {}",
+ patch_text->GetName(), line.substr(1));
+ } else if (StartsWith(line, "//")) {
+ // Normal Comment
+ last_comment = line.substr(2);
+ if (last_comment.find_first_not_of(' ') == std::string::npos)
+ continue;
+ if (last_comment.find_first_not_of(' ') != 0)
+ last_comment = last_comment.substr(last_comment.find_first_not_of(' '));
+ } else if (StartsWith(line, "@enabled") || StartsWith(line, "@disabled")) {
+ // Start of patch
+ const auto enabled = StartsWith(line, "@enabled");
+ if (i == 0)
+ return;
+ LOG_INFO(Loader, "[IPSwitchCompiler ('{}')] Parsing patch '{}' ({})",
+ patch_text->GetName(), last_comment, line.substr(1));
+
+ IPSwitchPatch patch{last_comment, enabled, {}};
+
+ // Read rest of patch
+ while (true) {
+ if (i + 1 >= lines.size())
+ break;
+ const auto patch_line = lines[++i];
+
+ // Start of new patch
+ if (StartsWith(patch_line, "@enabled") || StartsWith(patch_line, "@disabled")) {
+ --i;
+ break;
+ }
+
+ // Check for a flag
+ if (StartsWith(patch_line, "@")) {
+ ParseFlag(patch_line);
+ continue;
+ }
+
+ // 11 - 8 hex digit offset + space + minimum two digit overwrite val
+ if (patch_line.length() < 11)
+ break;
+ auto offset = std::stoul(patch_line.substr(0, 8), nullptr, 16);
+ offset += offset_shift;
+
+ std::vector<u8> replace;
+ // 9 - first char of replacement val
+ if (patch_line[9] == '\"') {
+ // string replacement
+ auto end_index = patch_line.find('\"', 10);
+ if (end_index == std::string::npos || end_index < 10)
+ return;
+ while (patch_line[end_index - 1] == '\\') {
+ end_index = patch_line.find('\"', end_index + 1);
+ if (end_index == std::string::npos || end_index < 10)
+ return;
+ }
+
+ auto value = patch_line.substr(10, end_index - 10);
+ value = EscapeStringSequences(value);
+ replace.reserve(value.size());
+ std::copy(value.begin(), value.end(), std::back_inserter(replace));
+ } else {
+ // hex replacement
+ const auto value = patch_line.substr(9);
+ replace.reserve(value.size() / 2);
+ replace = Common::HexStringToVector(value, is_little_endian);
+ }
+
+ if (print_values) {
+ LOG_INFO(Loader,
+ "[IPSwitchCompiler ('{}')] - Patching value at offset 0x{:08X} "
+ "with byte string '{}'",
+ patch_text->GetName(), offset, Common::HexVectorToString(replace));
+ }
+
+ patch.records.insert_or_assign(offset, std::move(replace));
+ }
+
+ patches.push_back(std::move(patch));
+ } else if (StartsWith(line, "@")) {
+ ParseFlag(line);
+ }
+ }
+
+ valid = true;
+}
+
+VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
+ if (in == nullptr || !valid)
+ return nullptr;
+
+ auto in_data = in->ReadAllBytes();
+
+ for (const auto& patch : patches) {
+ if (!patch.enabled)
+ continue;
+
+ for (const auto& record : patch.records) {
+ if (record.first >= in_data.size())
+ continue;
+ auto replace_size = record.second.size();
+ if (record.first + replace_size > in_data.size())
+ replace_size = in_data.size() - record.first;
+ for (std::size_t i = 0; i < replace_size; ++i)
+ in_data[i + record.first] = record.second[i];
+ }
+ }
+
+ return std::make_shared<VectorVfsFile>(std::move(in_data), in->GetName(),
+ in->GetContainingDirectory());
}
} // namespace FileSys
diff --git a/src/core/file_sys/ips_layer.h b/src/core/file_sys/ips_layer.h
index 81c163494..450b2f71e 100644
--- a/src/core/file_sys/ips_layer.h
+++ b/src/core/file_sys/ips_layer.h
@@ -4,12 +4,41 @@
#pragma once
+#include <array>
#include <memory>
+#include <vector>
+#include "common/common_types.h"
#include "core/file_sys/vfs.h"
namespace FileSys {
VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips);
+class IPSwitchCompiler {
+public:
+ explicit IPSwitchCompiler(VirtualFile patch_text);
+ ~IPSwitchCompiler();
+
+ std::array<u8, 0x20> GetBuildID() const;
+ bool IsValid() const;
+ VirtualFile Apply(const VirtualFile& in) const;
+
+private:
+ struct IPSwitchPatch;
+
+ void ParseFlag(const std::string& flag);
+ void Parse();
+
+ bool valid = false;
+
+ VirtualFile patch_text;
+ std::vector<IPSwitchPatch> patches;
+ std::array<u8, 0x20> nso_build_id{};
+ bool is_little_endian = false;
+ s64 offset_shift = 0;
+ bool print_values = false;
+ std::string last_comment = "";
+};
+
} // namespace FileSys
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index 1ac00ebb0..b14d7cb0a 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -73,27 +73,38 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
return exefs;
}
-static std::vector<VirtualFile> CollectIPSPatches(const std::vector<VirtualDir>& patch_dirs,
- const std::string& build_id) {
- std::vector<VirtualFile> ips;
- ips.reserve(patch_dirs.size());
+static std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
+ const std::string& build_id) {
+ std::vector<VirtualFile> out;
+ out.reserve(patch_dirs.size());
for (const auto& subdir : patch_dirs) {
auto exefs_dir = subdir->GetSubdirectory("exefs");
if (exefs_dir != nullptr) {
for (const auto& file : exefs_dir->GetFiles()) {
- if (file->GetExtension() != "ips")
- continue;
- auto name = file->GetName();
- const auto p1 = name.substr(0, name.find('.'));
- const auto this_build_id = p1.substr(0, p1.find_last_not_of('0') + 1);
-
- if (build_id == this_build_id)
- ips.push_back(file);
+ if (file->GetExtension() == "ips") {
+ auto name = file->GetName();
+ const auto p1 = name.substr(0, name.find('.'));
+ const auto this_build_id = p1.substr(0, p1.find_last_not_of('0') + 1);
+
+ if (build_id == this_build_id)
+ out.push_back(file);
+ } else if (file->GetExtension() == "pchtxt") {
+ IPSwitchCompiler compiler{file};
+ if (!compiler.IsValid())
+ continue;
+
+ auto this_build_id = Common::HexArrayToString(compiler.GetBuildID());
+ this_build_id =
+ this_build_id.substr(0, this_build_id.find_last_not_of('0') + 1);
+
+ if (build_id == this_build_id)
+ out.push_back(file);
+ }
}
}
}
- return ips;
+ return out;
}
std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
@@ -115,15 +126,24 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
auto patch_dirs = load_dir->GetSubdirectories();
std::sort(patch_dirs.begin(), patch_dirs.end(),
[](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
- const auto ips = CollectIPSPatches(patch_dirs, build_id);
+ const auto patches = CollectPatches(patch_dirs, build_id);
auto out = nso;
- for (const auto& ips_file : ips) {
- LOG_INFO(Loader, " - Appling IPS patch from mod \"{}\"",
- ips_file->GetContainingDirectory()->GetParentDirectory()->GetName());
- const auto patched = PatchIPS(std::make_shared<VectorVfsFile>(out), ips_file);
- if (patched != nullptr)
- out = patched->ReadAllBytes();
+ for (const auto& patch_file : patches) {
+ if (patch_file->GetExtension() == "ips") {
+ LOG_INFO(Loader, " - Applying IPS patch from mod \"{}\"",
+ patch_file->GetContainingDirectory()->GetParentDirectory()->GetName());
+ const auto patched = PatchIPS(std::make_shared<VectorVfsFile>(out), patch_file);
+ if (patched != nullptr)
+ out = patched->ReadAllBytes();
+ } else if (patch_file->GetExtension() == "pchtxt") {
+ LOG_INFO(Loader, " - Applying IPSwitch patch from mod \"{}\"",
+ patch_file->GetContainingDirectory()->GetParentDirectory()->GetName());
+ const IPSwitchCompiler compiler{patch_file};
+ const auto patched = compiler.Apply(std::make_shared<VectorVfsFile>(out));
+ if (patched != nullptr)
+ out = patched->ReadAllBytes();
+ }
}
if (out.size() < 0x100)
@@ -143,7 +163,7 @@ bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
std::sort(patch_dirs.begin(), patch_dirs.end(),
[](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
- return !CollectIPSPatches(patch_dirs, build_id).empty();
+ return !CollectPatches(patch_dirs, build_id).empty();
}
static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
@@ -162,11 +182,17 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
[](const VirtualDir& l, const VirtualDir& r) { return l->GetName() < r->GetName(); });
std::vector<VirtualDir> layers;
+ std::vector<VirtualDir> layers_ext;
layers.reserve(patch_dirs.size() + 1);
+ layers_ext.reserve(patch_dirs.size() + 1);
for (const auto& subdir : patch_dirs) {
auto romfs_dir = subdir->GetSubdirectory("romfs");
if (romfs_dir != nullptr)
layers.push_back(std::move(romfs_dir));
+
+ auto ext_dir = subdir->GetSubdirectory("romfs_ext");
+ if (ext_dir != nullptr)
+ layers_ext.push_back(std::move(ext_dir));
}
layers.push_back(std::move(extracted));
@@ -175,7 +201,9 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
return;
}
- auto packed = CreateRomFS(std::move(layered));
+ auto layered_ext = LayeredVfsDirectory::MakeLayeredDirectory(std::move(layers_ext));
+
+ auto packed = CreateRomFS(std::move(layered), std::move(layered_ext));
if (packed == nullptr) {
return;
}
@@ -263,8 +291,24 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
for (const auto& mod : mod_dir->GetSubdirectories()) {
std::string types;
- if (IsDirValidAndNonEmpty(mod->GetSubdirectory("exefs")))
- AppendCommaIfNotEmpty(types, "IPS");
+
+ const auto exefs_dir = mod->GetSubdirectory("exefs");
+ if (IsDirValidAndNonEmpty(exefs_dir)) {
+ bool ips = false;
+ bool ipswitch = false;
+
+ for (const auto& file : exefs_dir->GetFiles()) {
+ if (file->GetExtension() == "ips")
+ ips = true;
+ else if (file->GetExtension() == "pchtxt")
+ ipswitch = true;
+ }
+
+ if (ips)
+ AppendCommaIfNotEmpty(types, "IPS");
+ if (ipswitch)
+ AppendCommaIfNotEmpty(types, "IPSwitch");
+ }
if (IsDirValidAndNonEmpty(mod->GetSubdirectory("romfs")))
AppendCommaIfNotEmpty(types, "LayeredFS");
diff --git a/src/core/file_sys/patch_manager.h b/src/core/file_sys/patch_manager.h
index 2ae9322a1..eb6fc4607 100644
--- a/src/core/file_sys/patch_manager.h
+++ b/src/core/file_sys/patch_manager.h
@@ -36,6 +36,7 @@ public:
// Currently tracked NSO patches:
// - IPS
+ // - IPSwitch
std::vector<u8> PatchNSO(const std::vector<u8>& nso) const;
// Checks to see if PatchNSO() will have any effect given the NSO's build ID.
diff --git a/src/core/file_sys/romfs.cpp b/src/core/file_sys/romfs.cpp
index 5910f7046..81e1f66ac 100644
--- a/src/core/file_sys/romfs.cpp
+++ b/src/core/file_sys/romfs.cpp
@@ -129,11 +129,11 @@ VirtualDir ExtractRomFS(VirtualFile file, RomFSExtractionType type) {
return out;
}
-VirtualFile CreateRomFS(VirtualDir dir) {
+VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
if (dir == nullptr)
return nullptr;
- RomFSBuildContext ctx{dir};
+ RomFSBuildContext ctx{dir, ext};
return ConcatenatedVfsFile::MakeConcatenatedFile(0, ctx.Build(), dir->GetName());
}
diff --git a/src/core/file_sys/romfs.h b/src/core/file_sys/romfs.h
index ecd1eb725..0ec404731 100644
--- a/src/core/file_sys/romfs.h
+++ b/src/core/file_sys/romfs.h
@@ -44,6 +44,6 @@ VirtualDir ExtractRomFS(VirtualFile file,
// Converts a VFS filesystem into a RomFS binary
// Returns nullptr on failure
-VirtualFile CreateRomFS(VirtualDir dir);
+VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext = nullptr);
} // namespace FileSys
diff --git a/src/core/telemetry_session.cpp b/src/core/telemetry_session.cpp
index f29fff1e7..7b04792b5 100644
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -2,12 +2,16 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
+#include <array>
+
+#include <mbedtls/ctr_drbg.h>
+#include <mbedtls/entropy.h>
+
#include "common/assert.h"
#include "common/common_types.h"
#include "common/file_util.h"
+#include "common/logging/log.h"
-#include <mbedtls/ctr_drbg.h>
-#include <mbedtls/entropy.h>
#include "core/core.h"
#include "core/file_sys/control_metadata.h"
#include "core/file_sys/patch_manager.h"
@@ -28,11 +32,11 @@ static u64 GenerateTelemetryId() {
mbedtls_entropy_context entropy;
mbedtls_entropy_init(&entropy);
mbedtls_ctr_drbg_context ctr_drbg;
- std::string personalization = "yuzu Telemetry ID";
+ constexpr std::array<char, 18> personalization{{"yuzu Telemetry ID"}};
mbedtls_ctr_drbg_init(&ctr_drbg);
ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
- reinterpret_cast<const unsigned char*>(personalization.c_str()),
+ reinterpret_cast<const unsigned char*>(personalization.data()),
personalization.size()) == 0);
ASSERT(mbedtls_ctr_drbg_random(&ctr_drbg, reinterpret_cast<unsigned char*>(&telemetry_id),
sizeof(u64)) == 0);
diff --git a/src/core/telemetry_session.h b/src/core/telemetry_session.h
index cec271df0..2a4845797 100644
--- a/src/core/telemetry_session.h
+++ b/src/core/telemetry_session.h
@@ -5,6 +5,7 @@
#pragma once
#include <memory>
+#include <string>
#include "common/telemetry.h"
namespace Core {
@@ -30,8 +31,6 @@ public:
field_collection.AddField(type, name, std::move(value));
}
- static void FinalizeAsyncJob();
-
private:
Telemetry::FieldCollection field_collection; ///< Tracks all added fields for the session
std::unique_ptr<Telemetry::VisitorInterface> backend; ///< Backend interface that logs fields
@@ -53,7 +52,6 @@ u64 RegenerateTelemetryId();
* Verifies the username and token.
* @param username yuzu username to use for authentication.
* @param token yuzu token to use for authentication.
- * @param func A function that gets exectued when the verification is finished
* @returns Future with bool indicating whether the verification succeeded
*/
bool VerifyLogin(const std::string& username, const std::string& token);
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-08 22:27:57 +0100