From 84cb20bc72031947ac9e625b4a2b5e0059dda441 Mon Sep 17 00:00:00 2001 From: Liam Date: Fri, 14 Jul 2023 20:16:39 -0400 Subject: [PATCH 1/4] core: remove ResultVal type --- src/core/file_sys/romfs_factory.cpp | 25 +-- src/core/file_sys/romfs_factory.h | 12 +- src/core/file_sys/savedata_factory.cpp | 22 +-- src/core/file_sys/savedata_factory.h | 4 +- src/core/file_sys/sdmc_factory.cpp | 2 +- src/core/file_sys/sdmc_factory.h | 2 +- src/core/hle/kernel/k_page_table.cpp | 2 +- src/core/hle/result.h | 153 ------------------ src/core/hle/service/acc/acc.cpp | 11 +- src/core/hle/service/am/am.cpp | 26 +-- .../hle/service/filesystem/filesystem.cpp | 142 +++++++++------- src/core/hle/service/filesystem/filesystem.h | 43 ++--- src/core/hle/service/filesystem/fsp_srv.cpp | 75 +++++---- src/core/hle/service/glue/arp.cpp | 36 +++-- src/core/hle/service/glue/glue_manager.cpp | 11 +- src/core/hle/service/glue/glue_manager.h | 4 +- src/core/hle/service/ldr/ldr.cpp | 46 +++--- src/core/hle/service/mii/mii.cpp | 34 ++-- src/core/hle/service/mii/mii_manager.cpp | 5 +- src/core/hle/service/mii/mii_manager.h | 4 +- src/core/hle/service/ns/ns.cpp | 41 ++--- src/core/hle/service/ns/ns.h | 5 +- .../hle/service/nvnflinger/nvnflinger.cpp | 4 +- src/core/hle/service/nvnflinger/nvnflinger.h | 2 +- src/core/hle/service/server_manager.cpp | 9 +- src/core/hle/service/sm/sm.cpp | 43 ++--- src/core/hle/service/sm/sm.h | 4 +- src/core/hle/service/spl/spl_module.cpp | 48 +++--- src/core/hle/service/spl/spl_module.h | 2 +- .../hle/service/vi/display/vi_display.cpp | 5 +- src/core/hle/service/vi/display/vi_display.h | 2 +- src/core/hle/service/vi/vi.cpp | 33 ++-- 32 files changed, 374 insertions(+), 483 deletions(-) diff --git a/src/core/file_sys/romfs_factory.cpp b/src/core/file_sys/romfs_factory.cpp index ae7a3511b..aa4726cfa 100644 --- a/src/core/file_sys/romfs_factory.cpp +++ b/src/core/file_sys/romfs_factory.cpp @@ -35,7 +35,7 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) { update_raw = std::move(update_raw_file); } -ResultVal RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const { +VirtualFile RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const { if (!updatable) { return file; } @@ -45,12 +45,11 @@ ResultVal RomFSFactory::OpenCurrentProcess(u64 current_process_titl return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw); } -ResultVal RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const { +VirtualFile RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const { auto nca = content_provider.GetEntry(title_id, type); if (nca == nullptr) { - // TODO: Find the right error code to use here - return ResultUnknown; + return nullptr; } const PatchManager patch_manager{title_id, filesystem_controller, content_provider}; @@ -58,28 +57,20 @@ ResultVal RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type); } -ResultVal RomFSFactory::OpenPatchedRomFSWithProgramIndex( - u64 title_id, u8 program_index, ContentRecordType type) const { +VirtualFile RomFSFactory::OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index, + ContentRecordType type) const { const auto res_title_id = GetBaseTitleIDWithProgramIndex(title_id, program_index); return OpenPatchedRomFS(res_title_id, type); } -ResultVal RomFSFactory::Open(u64 title_id, StorageId storage, - ContentRecordType type) const { +VirtualFile RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) const { const std::shared_ptr res = GetEntry(title_id, storage, type); if (res == nullptr) { - // TODO(DarkLordZach): Find the right error code to use here - return ResultUnknown; + return nullptr; } - const auto romfs = res->GetRomFS(); - if (romfs == nullptr) { - // TODO(DarkLordZach): Find the right error code to use here - return ResultUnknown; - } - - return romfs; + return res->GetRomFS(); } std::shared_ptr RomFSFactory::GetEntry(u64 title_id, StorageId storage, diff --git a/src/core/file_sys/romfs_factory.h b/src/core/file_sys/romfs_factory.h index 14936031f..7ec40d19d 100644 --- a/src/core/file_sys/romfs_factory.h +++ b/src/core/file_sys/romfs_factory.h @@ -41,13 +41,11 @@ public: ~RomFSFactory(); void SetPackedUpdate(VirtualFile update_raw_file); - [[nodiscard]] ResultVal OpenCurrentProcess(u64 current_process_title_id) const; - [[nodiscard]] ResultVal OpenPatchedRomFS(u64 title_id, - ContentRecordType type) const; - [[nodiscard]] ResultVal OpenPatchedRomFSWithProgramIndex( - u64 title_id, u8 program_index, ContentRecordType type) const; - [[nodiscard]] ResultVal Open(u64 title_id, StorageId storage, - ContentRecordType type) const; + [[nodiscard]] VirtualFile OpenCurrentProcess(u64 current_process_title_id) const; + [[nodiscard]] VirtualFile OpenPatchedRomFS(u64 title_id, ContentRecordType type) const; + [[nodiscard]] VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index, + ContentRecordType type) const; + [[nodiscard]] VirtualFile Open(u64 title_id, StorageId storage, ContentRecordType type) const; private: [[nodiscard]] std::shared_ptr GetEntry(u64 title_id, StorageId storage, diff --git a/src/core/file_sys/savedata_factory.cpp b/src/core/file_sys/savedata_factory.cpp index 70b36f170..a4d060007 100644 --- a/src/core/file_sys/savedata_factory.cpp +++ b/src/core/file_sys/savedata_factory.cpp @@ -108,26 +108,16 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, VirtualDir save_director SaveDataFactory::~SaveDataFactory() = default; -ResultVal SaveDataFactory::Create(SaveDataSpaceId space, - const SaveDataAttribute& meta) const { +VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const { PrintSaveDataAttributeWarnings(meta); const auto save_directory = GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id); - auto out = dir->CreateDirectoryRelative(save_directory); - - // Return an error if the save data doesn't actually exist. - if (out == nullptr) { - // TODO(DarkLordZach): Find out correct error code. - return ResultUnknown; - } - - return out; + return dir->CreateDirectoryRelative(save_directory); } -ResultVal SaveDataFactory::Open(SaveDataSpaceId space, - const SaveDataAttribute& meta) const { +VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const { const auto save_directory = GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id); @@ -138,12 +128,6 @@ ResultVal SaveDataFactory::Open(SaveDataSpaceId space, return Create(space, meta); } - // Return an error if the save data doesn't actually exist. - if (out == nullptr) { - // TODO(Subv): Find out correct error code. - return ResultUnknown; - } - return out; } diff --git a/src/core/file_sys/savedata_factory.h b/src/core/file_sys/savedata_factory.h index d3633ef03..45c7c81fb 100644 --- a/src/core/file_sys/savedata_factory.h +++ b/src/core/file_sys/savedata_factory.h @@ -89,8 +89,8 @@ public: explicit SaveDataFactory(Core::System& system_, VirtualDir save_directory_); ~SaveDataFactory(); - ResultVal Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const; - ResultVal Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const; + VirtualDir Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const; + VirtualDir Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const; VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const; diff --git a/src/core/file_sys/sdmc_factory.cpp b/src/core/file_sys/sdmc_factory.cpp index 1df022c9e..d5158cd64 100644 --- a/src/core/file_sys/sdmc_factory.cpp +++ b/src/core/file_sys/sdmc_factory.cpp @@ -23,7 +23,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_) SDMCFactory::~SDMCFactory() = default; -ResultVal SDMCFactory::Open() const { +VirtualDir SDMCFactory::Open() const { return sd_dir; } diff --git a/src/core/file_sys/sdmc_factory.h b/src/core/file_sys/sdmc_factory.h index 3aebfb25e..a445fdb16 100644 --- a/src/core/file_sys/sdmc_factory.h +++ b/src/core/file_sys/sdmc_factory.h @@ -18,7 +18,7 @@ public: explicit SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_); ~SDMCFactory(); - ResultVal Open() const; + VirtualDir Open() const; VirtualDir GetSDMCModificationLoadRoot(u64 title_id) const; VirtualDir GetSDMCContentDirectory() const; diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp index 02b5cada4..9bfc85b34 100644 --- a/src/core/hle/kernel/k_page_table.cpp +++ b/src/core/hle/kernel/k_page_table.cpp @@ -768,7 +768,7 @@ Result KPageTable::UnmapProcessMemory(KProcessAddress dst_addr, size_t size, m_memory_block_slab_manager, num_allocator_blocks); R_TRY(allocator_result); - CASCADE_CODE(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap)); + R_TRY(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap)); // Apply the memory block update. m_memory_block_manager.Update(std::addressof(allocator), dst_addr, num_pages, diff --git a/src/core/hle/result.h b/src/core/hle/result.h index 240f06689..92a1439eb 100644 --- a/src/core/hle/result.h +++ b/src/core/hle/result.h @@ -283,159 +283,6 @@ private: u32 description_end; }; -/** - * This is an optional value type. It holds a `Result` and, if that code is ResultSuccess, it - * also holds a result of type `T`. If the code is an error code (not ResultSuccess), then trying - * to access the inner value with operator* is undefined behavior and will assert with Unwrap(). - * Users of this class must be cognizant to check the status of the ResultVal with operator bool(), - * Code(), Succeeded() or Failed() prior to accessing the inner value. - * - * An example of how it could be used: - * \code - * ResultVal Frobnicate(float strength) { - * if (strength < 0.f || strength > 1.0f) { - * // Can't frobnicate too weakly or too strongly - * return Result{ErrorModule::Common, 1}; - * } else { - * // Frobnicated! Give caller a cookie - * return 42; - * } - * } - * \endcode - * - * \code - * auto frob_result = Frobnicate(0.75f); - * if (frob_result) { - * // Frobbed ok - * printf("My cookie is %d\n", *frob_result); - * } else { - * printf("Guess I overdid it. :( Error code: %ux\n", frob_result.Code().raw); - * } - * \endcode - */ -template -class ResultVal { -public: - constexpr ResultVal() : expected{} {} - - constexpr ResultVal(Result code) : expected{Common::Unexpected(code)} {} - - constexpr ResultVal(ResultRange range) : expected{Common::Unexpected(range)} {} - - template - constexpr ResultVal(U&& val) : expected{std::forward(val)} {} - - template - constexpr ResultVal(Args&&... args) : expected{std::in_place, std::forward(args)...} {} - - ~ResultVal() = default; - - constexpr ResultVal(const ResultVal&) = default; - constexpr ResultVal(ResultVal&&) = default; - - ResultVal& operator=(const ResultVal&) = default; - ResultVal& operator=(ResultVal&&) = default; - - [[nodiscard]] constexpr explicit operator bool() const noexcept { - return expected.has_value(); - } - - [[nodiscard]] constexpr Result Code() const { - return expected.has_value() ? ResultSuccess : expected.error(); - } - - [[nodiscard]] constexpr bool Succeeded() const { - return expected.has_value(); - } - - [[nodiscard]] constexpr bool Failed() const { - return !expected.has_value(); - } - - [[nodiscard]] constexpr T* operator->() { - return std::addressof(expected.value()); - } - - [[nodiscard]] constexpr const T* operator->() const { - return std::addressof(expected.value()); - } - - [[nodiscard]] constexpr T& operator*() & { - return *expected; - } - - [[nodiscard]] constexpr const T& operator*() const& { - return *expected; - } - - [[nodiscard]] constexpr T&& operator*() && { - return *expected; - } - - [[nodiscard]] constexpr const T&& operator*() const&& { - return *expected; - } - - [[nodiscard]] constexpr T& Unwrap() & { - ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal"); - return expected.value(); - } - - [[nodiscard]] constexpr const T& Unwrap() const& { - ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal"); - return expected.value(); - } - - [[nodiscard]] constexpr T&& Unwrap() && { - ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal"); - return std::move(expected.value()); - } - - [[nodiscard]] constexpr const T&& Unwrap() const&& { - ASSERT_MSG(Succeeded(), "Tried to Unwrap empty ResultVal"); - return std::move(expected.value()); - } - - template - [[nodiscard]] constexpr T ValueOr(U&& v) const& { - return expected.value_or(v); - } - - template - [[nodiscard]] constexpr T ValueOr(U&& v) && { - return expected.value_or(v); - } - -private: - // TODO (Morph): Replace this with C++23 std::expected. - Common::Expected expected; -}; - -/** - * Check for the success of `source` (which must evaluate to a ResultVal). If it succeeds, unwraps - * the contained value and assigns it to `target`, which can be either an l-value expression or a - * variable declaration. If it fails the return code is returned from the current function. Thus it - * can be used to cascade errors out, achieving something akin to exception handling. - */ -#define CASCADE_RESULT(target, source) \ - auto CONCAT2(check_result_L, __LINE__) = source; \ - if (CONCAT2(check_result_L, __LINE__).Failed()) { \ - return CONCAT2(check_result_L, __LINE__).Code(); \ - } \ - target = std::move(*CONCAT2(check_result_L, __LINE__)) - -/** - * Analogous to CASCADE_RESULT, but for a bare Result. The code will be propagated if - * non-success, or discarded otherwise. - */ -#define CASCADE_CODE(source) \ - do { \ - auto CONCAT2(check_result_L, __LINE__) = source; \ - if (CONCAT2(check_result_L, __LINE__).IsError()) { \ - return CONCAT2(check_result_L, __LINE__); \ - } \ - } while (false) - #define R_SUCCEEDED(res) (static_cast(res).IsSuccess()) #define R_FAILED(res) (static_cast(res).IsFailure()) diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp index 2632cd3ef..b971401e6 100644 --- a/src/core/hle/service/acc/acc.cpp +++ b/src/core/hle/service/acc/acc.cpp @@ -765,15 +765,16 @@ Result Module::Interface::InitializeApplicationInfoBase() { // TODO(ogniK): This should be changed to reflect the target process for when we have multiple // processes emulated. As we don't actually have pid support we should assume we're just using // our own process - const auto launch_property = - system.GetARPManager().GetLaunchProperty(system.GetApplicationProcessProgramID()); + Glue::ApplicationLaunchProperty launch_property{}; + const auto result = system.GetARPManager().GetLaunchProperty( + &launch_property, system.GetApplicationProcessProgramID()); - if (launch_property.Failed()) { + if (result != ResultSuccess) { LOG_ERROR(Service_ACC, "Failed to get launch property"); return Account::ResultInvalidApplication; } - switch (launch_property->base_game_storage_id) { + switch (launch_property.base_game_storage_id) { case FileSys::StorageId::GameCard: application_info.application_type = ApplicationType::GameCard; break; @@ -785,7 +786,7 @@ Result Module::Interface::InitializeApplicationInfoBase() { break; default: LOG_ERROR(Service_ACC, "Invalid game storage ID! storage_id={}", - launch_property->base_game_storage_id); + launch_property.base_game_storage_id); return Account::ResultInvalidApplication; } diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp index 585675718..8d057b3a8 100644 --- a/src/core/hle/service/am/am.cpp +++ b/src/core/hle/service/am/am.cpp @@ -1578,11 +1578,13 @@ void IApplicationFunctions::EnsureSaveData(HLERequestContext& ctx) { attribute.title_id = system.GetApplicationProcessProgramID(); attribute.user_id = user_id; attribute.type = FileSys::SaveDataType::SaveData; + + FileSys::VirtualDir save_data{}; const auto res = system.GetFileSystemController().CreateSaveData( - FileSys::SaveDataSpaceId::NandUser, attribute); + &save_data, FileSys::SaveDataSpaceId::NandUser, attribute); IPC::ResponseBuilder rb{ctx, 4}; - rb.Push(res.Code()); + rb.Push(res); rb.Push(0); } @@ -1667,26 +1669,30 @@ void IApplicationFunctions::GetDesiredLanguage(HLERequestContext& ctx) { auto app_man = ns_am2->GetApplicationManagerInterface(); // Get desired application language - const auto res_lang = app_man->GetApplicationDesiredLanguage(supported_languages); - if (res_lang.Failed()) { + u8 desired_language{}; + const auto res_lang = + app_man->GetApplicationDesiredLanguage(&desired_language, supported_languages); + if (res_lang != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res_lang.Code()); + rb.Push(res_lang); return; } // Convert to settings language code. - const auto res_code = app_man->ConvertApplicationLanguageToLanguageCode(*res_lang); - if (res_code.Failed()) { + u64 language_code{}; + const auto res_code = + app_man->ConvertApplicationLanguageToLanguageCode(&language_code, desired_language); + if (res_code != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res_code.Code()); + rb.Push(res_code); return; } - LOG_DEBUG(Service_AM, "got desired_language={:016X}", *res_code); + LOG_DEBUG(Service_AM, "got desired_language={:016X}", language_code); IPC::ResponseBuilder rb{ctx, 4}; rb.Push(ResultSuccess); - rb.Push(*res_code); + rb.Push(language_code); } void IApplicationFunctions::IsGamePlayRecordingSupported(HLERequestContext& ctx) { diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp index dfcdd3ada..d9b569789 100644 --- a/src/core/hle/service/filesystem/filesystem.cpp +++ b/src/core/hle/service/filesystem/filesystem.cpp @@ -57,8 +57,8 @@ Result VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size return FileSys::ERROR_PATH_NOT_FOUND; } - const auto entry_type = GetEntryType(path); - if (entry_type.Code() == ResultSuccess) { + FileSys::EntryType entry_type; + if (GetEntryType(&entry_type, path) == ResultSuccess) { return FileSys::ERROR_PATH_ALREADY_EXISTS; } @@ -210,8 +210,8 @@ Result VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_, return ResultUnknown; } -ResultVal VfsDirectoryServiceWrapper::OpenFile(const std::string& path_, - FileSys::Mode mode) const { +Result VfsDirectoryServiceWrapper::OpenFile(FileSys::VirtualFile* out_file, + const std::string& path_, FileSys::Mode mode) const { const std::string path(Common::FS::SanitizePath(path_)); std::string_view npath = path; while (!npath.empty() && (npath[0] == '/' || npath[0] == '\\')) { @@ -224,50 +224,68 @@ ResultVal VfsDirectoryServiceWrapper::OpenFile(const std:: } if (mode == FileSys::Mode::Append) { - return std::make_shared(file, 0, file->GetSize()); + *out_file = std::make_shared(file, 0, file->GetSize()); + } else { + *out_file = file; } - return file; + return ResultSuccess; } -ResultVal VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) { +Result VfsDirectoryServiceWrapper::OpenDirectory(FileSys::VirtualDir* out_directory, + const std::string& path_) { std::string path(Common::FS::SanitizePath(path_)); auto dir = GetDirectoryRelativeWrapped(backing, path); if (dir == nullptr) { // TODO(DarkLordZach): Find a better error code for this return FileSys::ERROR_PATH_NOT_FOUND; } - return dir; + *out_directory = dir; + return ResultSuccess; } -ResultVal VfsDirectoryServiceWrapper::GetEntryType( - const std::string& path_) const { +Result VfsDirectoryServiceWrapper::GetEntryType(FileSys::EntryType* out_entry_type, + const std::string& path_) const { std::string path(Common::FS::SanitizePath(path_)); auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path)); - if (dir == nullptr) - return FileSys::ERROR_PATH_NOT_FOUND; - auto filename = Common::FS::GetFilename(path); - // TODO(Subv): Some games use the '/' path, find out what this means. - if (filename.empty()) - return FileSys::EntryType::Directory; - - if (dir->GetFile(filename) != nullptr) - return FileSys::EntryType::File; - if (dir->GetSubdirectory(filename) != nullptr) - return FileSys::EntryType::Directory; - return FileSys::ERROR_PATH_NOT_FOUND; -} - -ResultVal VfsDirectoryServiceWrapper::GetFileTimeStampRaw( - const std::string& path) const { - auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path)); if (dir == nullptr) { return FileSys::ERROR_PATH_NOT_FOUND; } - if (GetEntryType(path).Failed()) { + + auto filename = Common::FS::GetFilename(path); + // TODO(Subv): Some games use the '/' path, find out what this means. + if (filename.empty()) { + *out_entry_type = FileSys::EntryType::Directory; + return ResultSuccess; + } + + if (dir->GetFile(filename) != nullptr) { + *out_entry_type = FileSys::EntryType::File; + return ResultSuccess; + } + + if (dir->GetSubdirectory(filename) != nullptr) { + *out_entry_type = FileSys::EntryType::Directory; + return ResultSuccess; + } + + return FileSys::ERROR_PATH_NOT_FOUND; +} + +Result VfsDirectoryServiceWrapper::GetFileTimeStampRaw( + FileSys::FileTimeStampRaw* out_file_time_stamp_raw, const std::string& path) const { + auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path)); + if (dir == nullptr) { return FileSys::ERROR_PATH_NOT_FOUND; } - return dir->GetFileTimeStamp(Common::FS::GetFilename(path)); + + FileSys::EntryType entry_type; + if (GetEntryType(&entry_type, path) != ResultSuccess) { + return FileSys::ERROR_PATH_NOT_FOUND; + } + + *out_file_time_stamp_raw = dir->GetFileTimeStamp(Common::FS::GetFilename(path)); + return ResultSuccess; } FileSystemController::FileSystemController(Core::System& system_) : system{system_} {} @@ -310,57 +328,54 @@ void FileSystemController::SetPackedUpdate(FileSys::VirtualFile update_raw) { romfs_factory->SetPackedUpdate(std::move(update_raw)); } -ResultVal FileSystemController::OpenRomFSCurrentProcess() const { +FileSys::VirtualFile FileSystemController::OpenRomFSCurrentProcess() const { LOG_TRACE(Service_FS, "Opening RomFS for current process"); if (romfs_factory == nullptr) { - // TODO(bunnei): Find a better error code for this - return ResultUnknown; + return nullptr; } return romfs_factory->OpenCurrentProcess(system.GetApplicationProcessProgramID()); } -ResultVal FileSystemController::OpenPatchedRomFS( - u64 title_id, FileSys::ContentRecordType type) const { +FileSys::VirtualFile FileSystemController::OpenPatchedRomFS(u64 title_id, + FileSys::ContentRecordType type) const { LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}", title_id); if (romfs_factory == nullptr) { - // TODO: Find a better error code for this - return ResultUnknown; + return nullptr; } return romfs_factory->OpenPatchedRomFS(title_id, type); } -ResultVal FileSystemController::OpenPatchedRomFSWithProgramIndex( +FileSys::VirtualFile FileSystemController::OpenPatchedRomFSWithProgramIndex( u64 title_id, u8 program_index, FileSys::ContentRecordType type) const { LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}, program_index={}", title_id, program_index); if (romfs_factory == nullptr) { - // TODO: Find a better error code for this - return ResultUnknown; + return nullptr; } return romfs_factory->OpenPatchedRomFSWithProgramIndex(title_id, program_index, type); } -ResultVal FileSystemController::OpenRomFS( - u64 title_id, FileSys::StorageId storage_id, FileSys::ContentRecordType type) const { +FileSys::VirtualFile FileSystemController::OpenRomFS(u64 title_id, FileSys::StorageId storage_id, + FileSys::ContentRecordType type) const { LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}", title_id, storage_id, type); if (romfs_factory == nullptr) { - // TODO(bunnei): Find a better error code for this - return ResultUnknown; + return nullptr; } return romfs_factory->Open(title_id, storage_id, type); } -ResultVal FileSystemController::CreateSaveData( - FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const { +Result FileSystemController::CreateSaveData(FileSys::VirtualDir* out_save_data, + FileSys::SaveDataSpaceId space, + const FileSys::SaveDataAttribute& save_struct) const { LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}", space, save_struct.DebugInfo()); @@ -368,11 +383,13 @@ ResultVal FileSystemController::CreateSaveData( return FileSys::ERROR_ENTITY_NOT_FOUND; } - return save_data_factory->Create(space, save_struct); + *out_save_data = save_data_factory->Create(space, save_struct); + return ResultSuccess; } -ResultVal FileSystemController::OpenSaveData( - FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& attribute) const { +Result FileSystemController::OpenSaveData(FileSys::VirtualDir* out_save_data, + FileSys::SaveDataSpaceId space, + const FileSys::SaveDataAttribute& attribute) const { LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}", space, attribute.DebugInfo()); @@ -380,32 +397,35 @@ ResultVal FileSystemController::OpenSaveData( return FileSys::ERROR_ENTITY_NOT_FOUND; } - return save_data_factory->Open(space, attribute); + *out_save_data = save_data_factory->Open(space, attribute); + return ResultSuccess; } -ResultVal FileSystemController::OpenSaveDataSpace( - FileSys::SaveDataSpaceId space) const { +Result FileSystemController::OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space, + FileSys::SaveDataSpaceId space) const { LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", space); if (save_data_factory == nullptr) { return FileSys::ERROR_ENTITY_NOT_FOUND; } - return save_data_factory->GetSaveDataSpaceDirectory(space); + *out_save_data_space = save_data_factory->GetSaveDataSpaceDirectory(space); + return ResultSuccess; } -ResultVal FileSystemController::OpenSDMC() const { +Result FileSystemController::OpenSDMC(FileSys::VirtualDir* out_sdmc) const { LOG_TRACE(Service_FS, "Opening SDMC"); if (sdmc_factory == nullptr) { return FileSys::ERROR_SD_CARD_NOT_FOUND; } - return sdmc_factory->Open(); + *out_sdmc = sdmc_factory->Open(); + return ResultSuccess; } -ResultVal FileSystemController::OpenBISPartition( - FileSys::BisPartitionId id) const { +Result FileSystemController::OpenBISPartition(FileSys::VirtualDir* out_bis_partition, + FileSys::BisPartitionId id) const { LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", id); if (bis_factory == nullptr) { @@ -417,11 +437,12 @@ ResultVal FileSystemController::OpenBISPartition( return FileSys::ERROR_INVALID_ARGUMENT; } - return part; + *out_bis_partition = part; + return ResultSuccess; } -ResultVal FileSystemController::OpenBISPartitionStorage( - FileSys::BisPartitionId id) const { +Result FileSystemController::OpenBISPartitionStorage( + FileSys::VirtualFile* out_bis_partition_storage, FileSys::BisPartitionId id) const { LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", id); if (bis_factory == nullptr) { @@ -433,7 +454,8 @@ ResultVal FileSystemController::OpenBISPartitionStorage( return FileSys::ERROR_INVALID_ARGUMENT; } - return part; + *out_bis_partition_storage = part; + return ResultSuccess; } u64 FileSystemController::GetFreeSpaceSize(FileSys::StorageId id) const { diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h index a5c1c9d3e..fd991f976 100644 --- a/src/core/hle/service/filesystem/filesystem.h +++ b/src/core/hle/service/filesystem/filesystem.h @@ -64,21 +64,24 @@ public: Result RegisterBIS(std::unique_ptr&& factory); void SetPackedUpdate(FileSys::VirtualFile update_raw); - ResultVal OpenRomFSCurrentProcess() const; - ResultVal OpenPatchedRomFS(u64 title_id, - FileSys::ContentRecordType type) const; - ResultVal OpenPatchedRomFSWithProgramIndex( - u64 title_id, u8 program_index, FileSys::ContentRecordType type) const; - ResultVal OpenRomFS(u64 title_id, FileSys::StorageId storage_id, - FileSys::ContentRecordType type) const; - ResultVal CreateSaveData( - FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const; - ResultVal OpenSaveData( - FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const; - ResultVal OpenSaveDataSpace(FileSys::SaveDataSpaceId space) const; - ResultVal OpenSDMC() const; - ResultVal OpenBISPartition(FileSys::BisPartitionId id) const; - ResultVal OpenBISPartitionStorage(FileSys::BisPartitionId id) const; + FileSys::VirtualFile OpenRomFSCurrentProcess() const; + FileSys::VirtualFile OpenPatchedRomFS(u64 title_id, FileSys::ContentRecordType type) const; + FileSys::VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index, + FileSys::ContentRecordType type) const; + FileSys::VirtualFile OpenRomFS(u64 title_id, FileSys::StorageId storage_id, + FileSys::ContentRecordType type) const; + + Result CreateSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space, + const FileSys::SaveDataAttribute& save_struct) const; + Result OpenSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space, + const FileSys::SaveDataAttribute& save_struct) const; + Result OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space, + FileSys::SaveDataSpaceId space) const; + Result OpenSDMC(FileSys::VirtualDir* out_sdmc) const; + Result OpenBISPartition(FileSys::VirtualDir* out_bis_partition, + FileSys::BisPartitionId id) const; + Result OpenBISPartitionStorage(FileSys::VirtualFile* out_bis_partition_storage, + FileSys::BisPartitionId id) const; u64 GetFreeSpaceSize(FileSys::StorageId id) const; u64 GetTotalSpaceSize(FileSys::StorageId id) const; @@ -224,26 +227,28 @@ public: * @param mode Mode to open the file with * @return Opened file, or error code */ - ResultVal OpenFile(const std::string& path, FileSys::Mode mode) const; + Result OpenFile(FileSys::VirtualFile* out_file, const std::string& path, + FileSys::Mode mode) const; /** * Open a directory specified by its path * @param path Path relative to the archive * @return Opened directory, or error code */ - ResultVal OpenDirectory(const std::string& path); + Result OpenDirectory(FileSys::VirtualDir* out_directory, const std::string& path); /** * Get the type of the specified path * @return The type of the specified path or error code */ - ResultVal GetEntryType(const std::string& path) const; + Result GetEntryType(FileSys::EntryType* out_entry_type, const std::string& path) const; /** * Get the timestamp of the specified path * @return The timestamp of the specified path or error code */ - ResultVal GetFileTimeStampRaw(const std::string& path) const; + Result GetFileTimeStampRaw(FileSys::FileTimeStampRaw* out_time_stamp_raw, + const std::string& path) const; private: FileSys::VirtualDir backing; diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp index 427dbc8b3..423a814cb 100644 --- a/src/core/hle/service/filesystem/fsp_srv.cpp +++ b/src/core/hle/service/filesystem/fsp_srv.cpp @@ -419,14 +419,15 @@ public: LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode); - auto result = backend.OpenFile(name, mode); - if (result.Failed()) { + FileSys::VirtualFile vfs_file{}; + auto result = backend.OpenFile(&vfs_file, name, mode); + if (result != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); + rb.Push(result); return; } - auto file = std::make_shared(system, result.Unwrap()); + auto file = std::make_shared(system, vfs_file); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; rb.Push(ResultSuccess); @@ -444,14 +445,15 @@ public: LOG_DEBUG(Service_FS, "called. directory={}, filter={}", name, filter_flags); - auto result = backend.OpenDirectory(name); - if (result.Failed()) { + FileSys::VirtualDir vfs_dir{}; + auto result = backend.OpenDirectory(&vfs_dir, name); + if (result != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); + rb.Push(result); return; } - auto directory = std::make_shared(system, result.Unwrap()); + auto directory = std::make_shared(system, vfs_dir); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; rb.Push(ResultSuccess); @@ -464,16 +466,17 @@ public: LOG_DEBUG(Service_FS, "called. file={}", name); - auto result = backend.GetEntryType(name); - if (result.Failed()) { + FileSys::EntryType vfs_entry_type{}; + auto result = backend.GetEntryType(&vfs_entry_type, name); + if (result != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); + rb.Push(result); return; } IPC::ResponseBuilder rb{ctx, 3}; rb.Push(ResultSuccess); - rb.Push(static_cast(*result)); + rb.Push(static_cast(vfs_entry_type)); } void Commit(HLERequestContext& ctx) { @@ -505,16 +508,17 @@ public: LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name); - auto result = backend.GetFileTimeStampRaw(name); - if (result.Failed()) { + FileSys::FileTimeStampRaw vfs_timestamp{}; + auto result = backend.GetFileTimeStampRaw(&vfs_timestamp, name); + if (result != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); + rb.Push(result); return; } IPC::ResponseBuilder rb{ctx, 10}; rb.Push(ResultSuccess); - rb.PushRaw(*result); + rb.PushRaw(vfs_timestamp); } private: @@ -572,14 +576,15 @@ private: } void FindAllSaves(FileSys::SaveDataSpaceId space) { - const auto save_root = fsc.OpenSaveDataSpace(space); + FileSys::VirtualDir save_root{}; + const auto result = fsc.OpenSaveDataSpace(&save_root, space); - if (save_root.Failed() || *save_root == nullptr) { + if (result != ResultSuccess || save_root == nullptr) { LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space); return; } - for (const auto& type : (*save_root)->GetSubdirectories()) { + for (const auto& type : save_root->GetSubdirectories()) { if (type->GetName() == "save") { for (const auto& save_id : type->GetSubdirectories()) { for (const auto& user_id : save_id->GetSubdirectories()) { @@ -837,9 +842,11 @@ void FSP_SRV::OpenFileSystemWithPatch(HLERequestContext& ctx) { void FSP_SRV::OpenSdCardFileSystem(HLERequestContext& ctx) { LOG_DEBUG(Service_FS, "called"); - auto filesystem = - std::make_shared(system, fsc.OpenSDMC().Unwrap(), - SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard)); + FileSys::VirtualDir sdmc_dir{}; + fsc.OpenSDMC(&sdmc_dir); + + auto filesystem = std::make_shared( + system, sdmc_dir, SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard)); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; rb.Push(ResultSuccess); @@ -856,7 +863,8 @@ void FSP_SRV::CreateSaveDataFileSystem(HLERequestContext& ctx) { LOG_DEBUG(Service_FS, "called save_struct = {}, uid = {:016X}{:016X}", save_struct.DebugInfo(), uid[1], uid[0]); - fsc.CreateSaveData(FileSys::SaveDataSpaceId::NandUser, save_struct); + FileSys::VirtualDir save_data_dir{}; + fsc.CreateSaveData(&save_data_dir, FileSys::SaveDataSpaceId::NandUser, save_struct); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(ResultSuccess); @@ -874,8 +882,9 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) { LOG_INFO(Service_FS, "called."); - auto dir = fsc.OpenSaveData(parameters.space_id, parameters.attribute); - if (dir.Failed()) { + FileSys::VirtualDir dir{}; + auto result = fsc.OpenSaveData(&dir, parameters.space_id, parameters.attribute); + if (result != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2, 0, 0}; rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND); return; @@ -899,8 +908,8 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) { ASSERT(false); } - auto filesystem = std::make_shared(system, std::move(dir.Unwrap()), - SizeGetter::FromStorageId(fsc, id)); + auto filesystem = + std::make_shared(system, std::move(dir), SizeGetter::FromStorageId(fsc, id)); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; rb.Push(ResultSuccess); @@ -970,7 +979,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) { if (!romfs) { auto current_romfs = fsc.OpenRomFSCurrentProcess(); - if (current_romfs.Failed()) { + if (!current_romfs) { // TODO (bunnei): Find the right error code to use here LOG_CRITICAL(Service_FS, "no file system interface available!"); IPC::ResponseBuilder rb{ctx, 2}; @@ -978,7 +987,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) { return; } - romfs = current_romfs.Unwrap(); + romfs = current_romfs; } auto storage = std::make_shared(system, romfs); @@ -999,7 +1008,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) { auto data = fsc.OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data); - if (data.Failed()) { + if (!data) { const auto archive = FileSys::SystemArchive::SynthesizeSystemArchive(title_id); if (archive != nullptr) { @@ -1021,7 +1030,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) { const FileSys::PatchManager pm{title_id, fsc, content_provider}; auto storage = std::make_shared( - system, pm.PatchRomFS(std::move(data.Unwrap()), 0, FileSys::ContentRecordType::Data)); + system, pm.PatchRomFS(std::move(data), 0, FileSys::ContentRecordType::Data)); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; rb.Push(ResultSuccess); @@ -1051,7 +1060,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) { fsc.OpenPatchedRomFSWithProgramIndex(system.GetApplicationProcessProgramID(), program_index, FileSys::ContentRecordType::Program); - if (patched_romfs.Failed()) { + if (!patched_romfs) { // TODO: Find the right error code to use here LOG_ERROR(Service_FS, "could not open storage with program_index={}", program_index); @@ -1060,7 +1069,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) { return; } - auto storage = std::make_shared(system, std::move(patched_romfs.Unwrap())); + auto storage = std::make_shared(system, std::move(patched_romfs)); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; rb.Push(ResultSuccess); diff --git a/src/core/hle/service/glue/arp.cpp b/src/core/hle/service/glue/arp.cpp index ed6fcb5f6..6f1151b03 100644 --- a/src/core/hle/service/glue/arp.cpp +++ b/src/core/hle/service/glue/arp.cpp @@ -65,18 +65,19 @@ void ARP_R::GetApplicationLaunchProperty(HLERequestContext& ctx) { return; } - const auto res = manager.GetLaunchProperty(*title_id); + ApplicationLaunchProperty launch_property{}; + const auto res = manager.GetLaunchProperty(&launch_property, *title_id); - if (res.Failed()) { + if (res != ResultSuccess) { LOG_ERROR(Service_ARP, "Failed to get launch property!"); IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res.Code()); + rb.Push(res); return; } IPC::ResponseBuilder rb{ctx, 6}; rb.Push(ResultSuccess); - rb.PushRaw(*res); + rb.PushRaw(launch_property); } void ARP_R::GetApplicationLaunchPropertyWithApplicationId(HLERequestContext& ctx) { @@ -85,18 +86,19 @@ void ARP_R::GetApplicationLaunchPropertyWithApplicationId(HLERequestContext& ctx LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id); - const auto res = manager.GetLaunchProperty(title_id); + ApplicationLaunchProperty launch_property{}; + const auto res = manager.GetLaunchProperty(&launch_property, title_id); - if (res.Failed()) { + if (res != ResultSuccess) { LOG_ERROR(Service_ARP, "Failed to get launch property!"); IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res.Code()); + rb.Push(res); return; } IPC::ResponseBuilder rb{ctx, 6}; rb.Push(ResultSuccess); - rb.PushRaw(*res); + rb.PushRaw(launch_property); } void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) { @@ -113,16 +115,17 @@ void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) { return; } - const auto res = manager.GetControlProperty(*title_id); + std::vector nacp_data; + const auto res = manager.GetControlProperty(&nacp_data, *title_id); - if (res.Failed()) { + if (res != ResultSuccess) { LOG_ERROR(Service_ARP, "Failed to get control property!"); IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res.Code()); + rb.Push(res); return; } - ctx.WriteBuffer(*res); + ctx.WriteBuffer(nacp_data); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(ResultSuccess); @@ -134,16 +137,17 @@ void ARP_R::GetApplicationControlPropertyWithApplicationId(HLERequestContext& ct LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id); - const auto res = manager.GetControlProperty(title_id); + std::vector nacp_data; + const auto res = manager.GetControlProperty(&nacp_data, title_id); - if (res.Failed()) { + if (res != ResultSuccess) { LOG_ERROR(Service_ARP, "Failed to get control property!"); IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res.Code()); + rb.Push(res); return; } - ctx.WriteBuffer(*res); + ctx.WriteBuffer(nacp_data); IPC::ResponseBuilder rb{ctx, 2}; rb.Push(ResultSuccess); diff --git a/src/core/hle/service/glue/glue_manager.cpp b/src/core/hle/service/glue/glue_manager.cpp index 4bf67921b..22f001704 100644 --- a/src/core/hle/service/glue/glue_manager.cpp +++ b/src/core/hle/service/glue/glue_manager.cpp @@ -15,7 +15,8 @@ ARPManager::ARPManager() = default; ARPManager::~ARPManager() = default; -ResultVal ARPManager::GetLaunchProperty(u64 title_id) const { +Result ARPManager::GetLaunchProperty(ApplicationLaunchProperty* out_launch_property, + u64 title_id) const { if (title_id == 0) { return Glue::ResultInvalidProcessId; } @@ -25,10 +26,11 @@ ResultVal ARPManager::GetLaunchProperty(u64 title_id) return Glue::ResultProcessIdNotRegistered; } - return iter->second.launch; + *out_launch_property = iter->second.launch; + return ResultSuccess; } -ResultVal> ARPManager::GetControlProperty(u64 title_id) const { +Result ARPManager::GetControlProperty(std::vector* out_control_property, u64 title_id) const { if (title_id == 0) { return Glue::ResultInvalidProcessId; } @@ -38,7 +40,8 @@ ResultVal> ARPManager::GetControlProperty(u64 title_id) const { return Glue::ResultProcessIdNotRegistered; } - return iter->second.control; + *out_control_property = iter->second.control; + return ResultSuccess; } Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch, diff --git a/src/core/hle/service/glue/glue_manager.h b/src/core/hle/service/glue/glue_manager.h index 1cf53d9d9..216aa34c1 100644 --- a/src/core/hle/service/glue/glue_manager.h +++ b/src/core/hle/service/glue/glue_manager.h @@ -32,12 +32,12 @@ public: // Returns the ApplicationLaunchProperty corresponding to the provided title ID if it was // previously registered, otherwise ResultProcessIdNotRegistered if it was never registered or // ResultInvalidProcessId if the title ID is 0. - ResultVal GetLaunchProperty(u64 title_id) const; + Result GetLaunchProperty(ApplicationLaunchProperty* out_launch_property, u64 title_id) const; // Returns a vector of the raw bytes of NACP data (necessarily 0x4000 in size) corresponding to // the provided title ID if it was previously registered, otherwise ResultProcessIdNotRegistered // if it was never registered or ResultInvalidProcessId if the title ID is 0. - ResultVal> GetControlProperty(u64 title_id) const; + Result GetControlProperty(std::vector* out_control_property, u64 title_id) const; // Adds a new entry to the internal database with the provided parameters, returning // ResultProcessIdNotRegistered if attempting to re-register a title ID without an intermediate diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp index 055c0a2db..95c5b7c8e 100644 --- a/src/core/hle/service/ldr/ldr.cpp +++ b/src/core/hle/service/ldr/ldr.cpp @@ -357,7 +357,8 @@ public: return ResultSuccess; } - ResultVal MapProcessCodeMemory(Kernel::KProcess* process, VAddr base_addr, u64 size) { + Result MapProcessCodeMemory(VAddr* out_map_location, Kernel::KProcess* process, VAddr base_addr, + u64 size) { auto& page_table{process->GetPageTable()}; VAddr addr{}; @@ -372,20 +373,21 @@ public: R_TRY(result); if (ValidateRegionForMap(page_table, addr, size)) { - return addr; + *out_map_location = addr; + return ResultSuccess; } } return ERROR_INSUFFICIENT_ADDRESS_SPACE; } - ResultVal MapNro(Kernel::KProcess* process, VAddr nro_addr, std::size_t nro_size, - VAddr bss_addr, std::size_t bss_size, std::size_t size) { + Result MapNro(VAddr* out_map_location, Kernel::KProcess* process, VAddr nro_addr, + std::size_t nro_size, VAddr bss_addr, std::size_t bss_size, std::size_t size) { for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) { auto& page_table{process->GetPageTable()}; VAddr addr{}; - CASCADE_RESULT(addr, MapProcessCodeMemory(process, nro_addr, nro_size)); + R_TRY(MapProcessCodeMemory(&addr, process, nro_addr, nro_size)); if (bss_size) { auto block_guard = detail::ScopeExit([&] { @@ -411,7 +413,8 @@ public: } if (ValidateRegionForMap(page_table, addr, size)) { - return addr; + *out_map_location = addr; + return ResultSuccess; } } @@ -437,9 +440,9 @@ public: CopyCode(nro_addr + nro_header.segment_headers[DATA_INDEX].memory_offset, data_start, nro_header.segment_headers[DATA_INDEX].memory_size); - CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission( + R_TRY(process->GetPageTable().SetProcessMemoryPermission( text_start, ro_start - text_start, Kernel::Svc::MemoryPermission::ReadExecute)); - CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission( + R_TRY(process->GetPageTable().SetProcessMemoryPermission( ro_start, data_start - ro_start, Kernel::Svc::MemoryPermission::Read)); return process->GetPageTable().SetProcessMemoryPermission( @@ -542,31 +545,32 @@ public: } // Map memory for the NRO - const auto map_result{MapNro(system.ApplicationProcess(), nro_address, nro_size, - bss_address, bss_size, nro_size + bss_size)}; - if (map_result.Failed()) { + VAddr map_location; + const auto map_result{MapNro(&map_location, system.ApplicationProcess(), nro_address, + nro_size, bss_address, bss_size, nro_size + bss_size)}; + if (map_result != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(map_result.Code()); + rb.Push(map_result); } // Load the NRO into the mapped memory if (const auto result{ - LoadNro(system.ApplicationProcess(), header, nro_address, *map_result)}; + LoadNro(system.ApplicationProcess(), header, nro_address, map_location)}; result.IsError()) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(map_result.Code()); + rb.Push(result); } // Track the loaded NRO - nro.insert_or_assign(*map_result, - NROInfo{hash, *map_result, nro_size, bss_address, bss_size, + nro.insert_or_assign(map_location, + NROInfo{hash, map_location, nro_size, bss_address, bss_size, header.segment_headers[TEXT_INDEX].memory_size, header.segment_headers[RO_INDEX].memory_size, header.segment_headers[DATA_INDEX].memory_size, nro_address}); IPC::ResponseBuilder rb{ctx, 4}; rb.Push(ResultSuccess); - rb.Push(*map_result); + rb.Push(map_location); } Result UnmapNro(const NROInfo& info) { @@ -574,19 +578,19 @@ public: auto& page_table{system.ApplicationProcess()->GetPageTable()}; if (info.bss_size != 0) { - CASCADE_CODE(page_table.UnmapCodeMemory( + R_TRY(page_table.UnmapCodeMemory( info.nro_address + info.text_size + info.ro_size + info.data_size, info.bss_address, info.bss_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); } - CASCADE_CODE(page_table.UnmapCodeMemory( + R_TRY(page_table.UnmapCodeMemory( info.nro_address + info.text_size + info.ro_size, info.src_addr + info.text_size + info.ro_size, info.data_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); - CASCADE_CODE(page_table.UnmapCodeMemory( + R_TRY(page_table.UnmapCodeMemory( info.nro_address + info.text_size, info.src_addr + info.text_size, info.ro_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); - CASCADE_CODE(page_table.UnmapCodeMemory( + R_TRY(page_table.UnmapCodeMemory( info.nro_address, info.src_addr, info.text_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); return ResultSuccess; diff --git a/src/core/hle/service/mii/mii.cpp b/src/core/hle/service/mii/mii.cpp index 5c7adf97d..65c11a2f3 100644 --- a/src/core/hle/service/mii/mii.cpp +++ b/src/core/hle/service/mii/mii.cpp @@ -101,20 +101,14 @@ private: LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag); - const auto result{manager.GetDefault(source_flag)}; - if (result.Failed()) { - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); - return; - } - - if (result->size() > 0) { - ctx.WriteBuffer(SerializeArray(*result)); + const auto default_miis{manager.GetDefault(source_flag)}; + if (default_miis.size() > 0) { + ctx.WriteBuffer(SerializeArray(default_miis)); } IPC::ResponseBuilder rb{ctx, 3}; rb.Push(ResultSuccess); - rb.Push(static_cast(result->size())); + rb.Push(static_cast(default_miis.size())); } void Get1(HLERequestContext& ctx) { @@ -123,15 +117,10 @@ private: LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag); - const auto result{manager.GetDefault(source_flag)}; - if (result.Failed()) { - IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); - return; - } + const auto default_miis{manager.GetDefault(source_flag)}; std::vector values; - for (const auto& element : *result) { + for (const auto& element : default_miis) { values.emplace_back(element.info); } @@ -139,7 +128,7 @@ private: IPC::ResponseBuilder rb{ctx, 3}; rb.Push(ResultSuccess); - rb.Push(static_cast(result->size())); + rb.Push(static_cast(default_miis.size())); } void UpdateLatest(HLERequestContext& ctx) { @@ -149,16 +138,17 @@ private: LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag); - const auto result{manager.UpdateLatest(info, source_flag)}; - if (result.Failed()) { + CharInfo new_char_info{}; + const auto result{manager.UpdateLatest(&new_char_info, info, source_flag)}; + if (result != ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); + rb.Push(result); return; } IPC::ResponseBuilder rb{ctx, 2 + sizeof(CharInfo) / sizeof(u32)}; rb.Push(ResultSuccess); - rb.PushRaw(*result); + rb.PushRaw(new_char_info); } void BuildRandom(HLERequestContext& ctx) { diff --git a/src/core/hle/service/mii/mii_manager.cpp b/src/core/hle/service/mii/mii_manager.cpp index c920650f5..46125d473 100644 --- a/src/core/hle/service/mii/mii_manager.cpp +++ b/src/core/hle/service/mii/mii_manager.cpp @@ -409,8 +409,7 @@ u32 MiiManager::GetCount(SourceFlag source_flag) const { return static_cast(count); } -ResultVal MiiManager::UpdateLatest([[maybe_unused]] const CharInfo& info, - SourceFlag source_flag) { +Result MiiManager::UpdateLatest(CharInfo* out_info, const CharInfo& info, SourceFlag source_flag) { if ((source_flag & SourceFlag::Database) == SourceFlag::None) { return ERROR_CANNOT_FIND_ENTRY; } @@ -672,7 +671,7 @@ bool MiiManager::ValidateV3Info(const Ver3StoreData& mii_v3) const { return is_valid; } -ResultVal> MiiManager::GetDefault(SourceFlag source_flag) { +std::vector MiiManager::GetDefault(SourceFlag source_flag) { std::vector result; if ((source_flag & SourceFlag::Default) == SourceFlag::None) { diff --git a/src/core/hle/service/mii/mii_manager.h b/src/core/hle/service/mii/mii_manager.h index 5525fcd1c..45c2be3c8 100644 --- a/src/core/hle/service/mii/mii_manager.h +++ b/src/core/hle/service/mii/mii_manager.h @@ -19,12 +19,12 @@ public: bool CheckAndResetUpdateCounter(SourceFlag source_flag, u64& current_update_counter); bool IsFullDatabase() const; u32 GetCount(SourceFlag source_flag) const; - ResultVal UpdateLatest(const CharInfo& info, SourceFlag source_flag); + Result UpdateLatest(CharInfo* out_info, const CharInfo& info, SourceFlag source_flag); CharInfo BuildRandom(Age age, Gender gender, Race race); CharInfo BuildDefault(std::size_t index); CharInfo ConvertV3ToCharInfo(const Ver3StoreData& mii_v3) const; bool ValidateV3Info(const Ver3StoreData& mii_v3) const; - ResultVal> GetDefault(SourceFlag source_flag); + std::vector GetDefault(SourceFlag source_flag); Result GetIndex(const CharInfo& info, u32& index); // This is nn::mii::detail::Ver::StoreDataRaw::BuildFromStoreData diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp index 91c5a2182..6e0baf0be 100644 --- a/src/core/hle/service/ns/ns.cpp +++ b/src/core/hle/service/ns/ns.cpp @@ -392,19 +392,20 @@ void IApplicationManagerInterface::GetApplicationDesiredLanguage(HLERequestConte IPC::RequestParser rp{ctx}; const auto supported_languages = rp.Pop(); - const auto res = GetApplicationDesiredLanguage(supported_languages); - if (res.Succeeded()) { + u8 desired_language{}; + const auto res = GetApplicationDesiredLanguage(&desired_language, supported_languages); + if (res == ResultSuccess) { IPC::ResponseBuilder rb{ctx, 3}; rb.Push(ResultSuccess); - rb.Push(*res); + rb.Push(desired_language); } else { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res.Code()); + rb.Push(res); } } -ResultVal IApplicationManagerInterface::GetApplicationDesiredLanguage( - const u32 supported_languages) { +Result IApplicationManagerInterface::GetApplicationDesiredLanguage(u8* out_desired_language, + const u32 supported_languages) { LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages); // Get language code from settings @@ -430,7 +431,8 @@ ResultVal IApplicationManagerInterface::GetApplicationDesiredLanguage( for (const auto lang : *priority_list) { const auto supported_flag = GetSupportedLanguageFlag(lang); if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) { - return static_cast(lang); + *out_desired_language = static_cast(lang); + return ResultSuccess; } } @@ -444,19 +446,20 @@ void IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode( IPC::RequestParser rp{ctx}; const auto application_language = rp.Pop(); - const auto res = ConvertApplicationLanguageToLanguageCode(application_language); - if (res.Succeeded()) { + u64 language_code{}; + const auto res = ConvertApplicationLanguageToLanguageCode(&language_code, application_language); + if (res == ResultSuccess) { IPC::ResponseBuilder rb{ctx, 4}; rb.Push(ResultSuccess); - rb.Push(*res); + rb.Push(language_code); } else { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(res.Code()); + rb.Push(res); } } -ResultVal IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode( - u8 application_language) { +Result IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode( + u64* out_language_code, u8 application_language) { const auto language_code = ConvertToLanguageCode(static_cast(application_language)); if (language_code == std::nullopt) { @@ -464,7 +467,8 @@ ResultVal IApplicationManagerInterface::ConvertApplicationLanguageToLanguag return Service::NS::ResultApplicationLanguageNotFound; } - return static_cast(*language_code); + *out_language_code = static_cast(*language_code); + return ResultSuccess; } IApplicationVersionInterface::IApplicationVersionInterface(Core::System& system_) @@ -618,12 +622,13 @@ void IReadOnlyApplicationControlDataInterface::GetApplicationControlData(HLERequ static_assert(sizeof(RequestParameters) == 0x10, "RequestParameters has incorrect size."); IPC::RequestParser rp{ctx}; + std::vector nacp_data{}; const auto parameters{rp.PopRaw()}; - const auto nacp_data{system.GetARPManager().GetControlProperty(parameters.application_id)}; - const auto result = nacp_data ? ResultSuccess : ResultUnknown; + const auto result = + system.GetARPManager().GetControlProperty(&nacp_data, parameters.application_id); - if (nacp_data) { - ctx.WriteBuffer(nacp_data->data(), nacp_data->size()); + if (result == ResultSuccess) { + ctx.WriteBuffer(nacp_data.data(), nacp_data.size()); } IPC::ResponseBuilder rb{ctx, 2}; diff --git a/src/core/hle/service/ns/ns.h b/src/core/hle/service/ns/ns.h index 203388e1f..175dad780 100644 --- a/src/core/hle/service/ns/ns.h +++ b/src/core/hle/service/ns/ns.h @@ -28,8 +28,9 @@ public: explicit IApplicationManagerInterface(Core::System& system_); ~IApplicationManagerInterface() override; - ResultVal GetApplicationDesiredLanguage(u32 supported_languages); - ResultVal ConvertApplicationLanguageToLanguageCode(u8 application_language); + Result GetApplicationDesiredLanguage(u8* out_desired_language, u32 supported_languages); + Result ConvertApplicationLanguageToLanguageCode(u64* out_language_code, + u8 application_language); private: void GetApplicationControlData(HLERequestContext& ctx); diff --git a/src/core/hle/service/nvnflinger/nvnflinger.cpp b/src/core/hle/service/nvnflinger/nvnflinger.cpp index 5f55cd31e..21f31f7a0 100644 --- a/src/core/hle/service/nvnflinger/nvnflinger.cpp +++ b/src/core/hle/service/nvnflinger/nvnflinger.cpp @@ -183,7 +183,7 @@ std::optional Nvnflinger::FindBufferQueueId(u64 display_id, u64 layer_id) { return layer->GetBinderId(); } -ResultVal Nvnflinger::FindVsyncEvent(u64 display_id) { +Result Nvnflinger::FindVsyncEvent(Kernel::KReadableEvent** out_vsync_event, u64 display_id) { const auto lock_guard = Lock(); auto* const display = FindDisplay(display_id); @@ -191,7 +191,7 @@ ResultVal Nvnflinger::FindVsyncEvent(u64 display_id) { return VI::ResultNotFound; } - return display->GetVSyncEvent(); + return display->GetVSyncEvent(out_vsync_event); } VI::Display* Nvnflinger::FindDisplay(u64 display_id) { diff --git a/src/core/hle/service/nvnflinger/nvnflinger.h b/src/core/hle/service/nvnflinger/nvnflinger.h index ef236303a..f478c2bc6 100644 --- a/src/core/hle/service/nvnflinger/nvnflinger.h +++ b/src/core/hle/service/nvnflinger/nvnflinger.h @@ -82,7 +82,7 @@ public: /// /// If an invalid display ID is provided, then VI::ResultNotFound is returned. /// If the vsync event has already been retrieved, then VI::ResultPermissionDenied is returned. - [[nodiscard]] ResultVal FindVsyncEvent(u64 display_id); + [[nodiscard]] Result FindVsyncEvent(Kernel::KReadableEvent** out_vsync_event, u64 display_id); /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when /// finished. diff --git a/src/core/hle/service/server_manager.cpp b/src/core/hle/service/server_manager.cpp index d1e99b184..e2e399534 100644 --- a/src/core/hle/service/server_manager.cpp +++ b/src/core/hle/service/server_manager.cpp @@ -102,16 +102,17 @@ Result ServerManager::RegisterNamedService(const std::string& service_name, m_system.ServiceManager().RegisterService(service_name, max_sessions, handler))); // Get the registered port. - auto port = m_system.ServiceManager().GetServicePort(service_name); - ASSERT(port.Succeeded()); + Kernel::KPort* port{}; + ASSERT( + R_SUCCEEDED(m_system.ServiceManager().GetServicePort(std::addressof(port), service_name))); // Open a new reference to the server port. - (*port)->GetServerPort().Open(); + port->GetServerPort().Open(); // Begin tracking the server port. { std::scoped_lock ll{m_list_mutex}; - m_ports.emplace(std::addressof((*port)->GetServerPort()), std::move(handler)); + m_ports.emplace(std::addressof(port->GetServerPort()), std::move(handler)); } // Signal the wakeup event. diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp index 1608fa24c..9ab718e0a 100644 --- a/src/core/hle/service/sm/sm.cpp +++ b/src/core/hle/service/sm/sm.cpp @@ -52,8 +52,7 @@ static Result ValidateServiceName(const std::string& name) { Result ServiceManager::RegisterService(std::string name, u32 max_sessions, SessionRequestHandlerPtr handler) { - - CASCADE_CODE(ValidateServiceName(name)); + R_TRY(ValidateServiceName(name)); std::scoped_lock lk{lock}; if (registered_services.find(name) != registered_services.end()) { @@ -77,7 +76,7 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions, } Result ServiceManager::UnregisterService(const std::string& name) { - CASCADE_CODE(ValidateServiceName(name)); + R_TRY(ValidateServiceName(name)); std::scoped_lock lk{lock}; const auto iter = registered_services.find(name); @@ -92,8 +91,8 @@ Result ServiceManager::UnregisterService(const std::string& name) { return ResultSuccess; } -ResultVal ServiceManager::GetServicePort(const std::string& name) { - CASCADE_CODE(ValidateServiceName(name)); +Result ServiceManager::GetServicePort(Kernel::KPort** out_port, const std::string& name) { + R_TRY(ValidateServiceName(name)); std::scoped_lock lk{lock}; auto it = service_ports.find(name); @@ -102,7 +101,8 @@ ResultVal ServiceManager::GetServicePort(const std::string& name return Service::SM::ResultNotRegistered; } - return it->second; + *out_port = it->second; + return ResultSuccess; } /** @@ -122,32 +122,34 @@ void SM::Initialize(HLERequestContext& ctx) { } void SM::GetService(HLERequestContext& ctx) { - auto result = GetServiceImpl(ctx); + Kernel::KClientSession* client_session{}; + auto result = GetServiceImpl(&client_session, ctx); if (ctx.GetIsDeferred()) { // Don't overwrite the command buffer. return; } - if (result.Succeeded()) { + if (result == ResultSuccess) { IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles}; - rb.Push(result.Code()); - rb.PushMoveObjects(result.Unwrap()); + rb.Push(result); + rb.PushMoveObjects(client_session); } else { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(result.Code()); + rb.Push(result); } } void SM::GetServiceTipc(HLERequestContext& ctx) { - auto result = GetServiceImpl(ctx); + Kernel::KClientSession* client_session{}; + auto result = GetServiceImpl(&client_session, ctx); if (ctx.GetIsDeferred()) { // Don't overwrite the command buffer. return; } IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles}; - rb.Push(result.Code()); - rb.PushMoveObjects(result.Succeeded() ? result.Unwrap() : nullptr); + rb.Push(result); + rb.PushMoveObjects(result == ResultSuccess ? client_session : nullptr); } static std::string PopServiceName(IPC::RequestParser& rp) { @@ -161,7 +163,7 @@ static std::string PopServiceName(IPC::RequestParser& rp) { return result; } -ResultVal SM::GetServiceImpl(HLERequestContext& ctx) { +Result SM::GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx) { if (!ctx.GetManager()->GetIsInitializedForSm()) { return Service::SM::ResultInvalidClient; } @@ -170,18 +172,18 @@ ResultVal SM::GetServiceImpl(HLERequestContext& ctx) { std::string name(PopServiceName(rp)); // Find the named port. - auto port_result = service_manager.GetServicePort(name); - if (port_result.Code() == Service::SM::ResultInvalidServiceName) { + Kernel::KPort* port{}; + auto port_result = service_manager.GetServicePort(&port, name); + if (port_result == Service::SM::ResultInvalidServiceName) { LOG_ERROR(Service_SM, "Invalid service name '{}'", name); return Service::SM::ResultInvalidServiceName; } - if (port_result.Failed()) { + if (port_result != ResultSuccess) { LOG_INFO(Service_SM, "Waiting for service {} to become available", name); ctx.SetIsDeferred(); return Service::SM::ResultNotRegistered; } - auto& port = port_result.Unwrap(); // Create a new session. Kernel::KClientSession* session{}; @@ -192,7 +194,8 @@ ResultVal SM::GetServiceImpl(HLERequestContext& ctx) { LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId()); - return session; + *out_client_session = session; + return ResultSuccess; } void SM::RegisterService(HLERequestContext& ctx) { diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h index 6697f4007..14bfaf8c2 100644 --- a/src/core/hle/service/sm/sm.h +++ b/src/core/hle/service/sm/sm.h @@ -42,7 +42,7 @@ private: void RegisterService(HLERequestContext& ctx); void UnregisterService(HLERequestContext& ctx); - ResultVal GetServiceImpl(HLERequestContext& ctx); + Result GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx); ServiceManager& service_manager; Kernel::KernelCore& kernel; @@ -55,7 +55,7 @@ public: Result RegisterService(std::string name, u32 max_sessions, SessionRequestHandlerPtr handler); Result UnregisterService(const std::string& name); - ResultVal GetServicePort(const std::string& name); + Result GetServicePort(Kernel::KPort** out_port, const std::string& name); template T> std::shared_ptr GetService(const std::string& service_name) const { diff --git a/src/core/hle/service/spl/spl_module.cpp b/src/core/hle/service/spl/spl_module.cpp index cd631b2ea..549e6f4fa 100644 --- a/src/core/hle/service/spl/spl_module.cpp +++ b/src/core/hle/service/spl/spl_module.cpp @@ -30,10 +30,10 @@ void Module::Interface::GetConfig(HLERequestContext& ctx) { // This should call svcCallSecureMonitor with the appropriate args. // Since we do not have it implemented yet, we will use this for now. - const auto smc_result = GetConfigImpl(config_item); - const auto result_code = smc_result.Code(); + u64 smc_result{}; + const auto result_code = GetConfigImpl(&smc_result, config_item); - if (smc_result.Failed()) { + if (result_code != ResultSuccess) { LOG_ERROR(Service_SPL, "called, config_item={}, result_code={}", config_item, result_code.raw); @@ -42,11 +42,11 @@ void Module::Interface::GetConfig(HLERequestContext& ctx) { } LOG_DEBUG(Service_SPL, "called, config_item={}, result_code={}, smc_result={}", config_item, - result_code.raw, *smc_result); + result_code.raw, smc_result); IPC::ResponseBuilder rb{ctx, 4}; rb.Push(result_code); - rb.Push(*smc_result); + rb.Push(smc_result); } void Module::Interface::ModularExponentiate(HLERequestContext& ctx) { @@ -99,7 +99,7 @@ void Module::Interface::GetBootReason(HLERequestContext& ctx) { rb.Push(ResultSecureMonitorNotImplemented); } -ResultVal Module::Interface::GetConfigImpl(ConfigItem config_item) const { +Result Module::Interface::GetConfigImpl(u64* out_config, ConfigItem config_item) const { switch (config_item) { case ConfigItem::DisableProgramVerification: case ConfigItem::DramId: @@ -121,40 +121,50 @@ ResultVal Module::Interface::GetConfigImpl(ConfigItem config_item) const { return ResultSecureMonitorNotImplemented; case ConfigItem::ExosphereApiVersion: // Get information about the current exosphere version. - return (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) | - (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) | - (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) | - (static_cast(HLE::ApiVersion::GetTargetFirmware())); + *out_config = (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) | + (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) | + (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) | + (static_cast(HLE::ApiVersion::GetTargetFirmware())); + return ResultSuccess; case ConfigItem::ExosphereNeedsReboot: // We are executing, so we aren't in the process of rebooting. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExosphereNeedsShutdown: // We are executing, so we aren't in the process of shutting down. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExosphereGitCommitHash: // Get information about the current exosphere git commit hash. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExosphereHasRcmBugPatch: // Get information about whether this unit has the RCM bug patched. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExosphereBlankProdInfo: // Get whether this unit should simulate a "blanked" PRODINFO. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExosphereAllowCalWrites: // Get whether this unit should allow writing to the calibration partition. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExosphereEmummcType: // Get what kind of emummc this unit has active. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExospherePayloadAddress: // Gets the physical address of the reboot payload buffer, if one exists. return ResultSecureMonitorNotInitialized; case ConfigItem::ExosphereLogConfiguration: // Get the log configuration. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; case ConfigItem::ExosphereForceEnableUsb30: // Get whether usb 3.0 should be force-enabled. - return u64{0}; + *out_config = u64{0}; + return ResultSuccess; default: return ResultSecureMonitorInvalidArgument; } diff --git a/src/core/hle/service/spl/spl_module.h b/src/core/hle/service/spl/spl_module.h index e074e115d..06dcffa6c 100644 --- a/src/core/hle/service/spl/spl_module.h +++ b/src/core/hle/service/spl/spl_module.h @@ -35,7 +35,7 @@ public: std::shared_ptr module; private: - ResultVal GetConfigImpl(ConfigItem config_item) const; + Result GetConfigImpl(u64* out_config, ConfigItem config_item) const; std::mt19937 rng; }; diff --git a/src/core/hle/service/vi/display/vi_display.cpp b/src/core/hle/service/vi/display/vi_display.cpp index 69af2868a..f0b5eff8a 100644 --- a/src/core/hle/service/vi/display/vi_display.cpp +++ b/src/core/hle/service/vi/display/vi_display.cpp @@ -58,14 +58,15 @@ const Layer& Display::GetLayer(std::size_t index) const { return *layers.at(index); } -ResultVal Display::GetVSyncEvent() { +Result Display::GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event) { if (got_vsync_event) { return ResultPermissionDenied; } got_vsync_event = true; - return GetVSyncEventUnchecked(); + *out_vsync_event = GetVSyncEventUnchecked(); + return ResultSuccess; } Kernel::KReadableEvent* Display::GetVSyncEventUnchecked() { diff --git a/src/core/hle/service/vi/display/vi_display.h b/src/core/hle/service/vi/display/vi_display.h index 3f31d1f32..101cbce20 100644 --- a/src/core/hle/service/vi/display/vi_display.h +++ b/src/core/hle/service/vi/display/vi_display.h @@ -85,7 +85,7 @@ public: * @returns The internal Vsync event if it has not yet been retrieved, * VI::ResultPermissionDenied otherwise. */ - [[nodiscard]] ResultVal GetVSyncEvent(); + [[nodiscard]] Result GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event); /// Gets the internal vsync event. Kernel::KReadableEvent* GetVSyncEventUnchecked(); diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp index 1b193f00c..5998e786e 100644 --- a/src/core/hle/service/vi/vi.cpp +++ b/src/core/hle/service/vi/vi.cpp @@ -683,9 +683,9 @@ private: LOG_DEBUG(Service_VI, "called. display_id={}", display_id); - const auto vsync_event = nv_flinger.FindVsyncEvent(display_id); - if (vsync_event.Failed()) { - const auto result = vsync_event.Code(); + Kernel::KReadableEvent* vsync_event{}; + const auto result = nv_flinger.FindVsyncEvent(&vsync_event, display_id); + if (result != ResultSuccess) { if (result == ResultNotFound) { LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id); } @@ -705,15 +705,16 @@ private: const auto mode = rp.PopEnum(); LOG_DEBUG(Service_VI, "called mode={}", mode); - const auto converted_mode = ConvertScalingModeImpl(mode); + ConvertedScaleMode converted_mode{}; + const auto result = ConvertScalingModeImpl(&converted_mode, mode); - if (converted_mode.Succeeded()) { + if (result == ResultSuccess) { IPC::ResponseBuilder rb{ctx, 4}; rb.Push(ResultSuccess); - rb.PushEnum(*converted_mode); + rb.PushEnum(converted_mode); } else { IPC::ResponseBuilder rb{ctx, 2}; - rb.Push(converted_mode.Code()); + rb.Push(result); } } @@ -760,18 +761,24 @@ private: rb.Push(alignment); } - static ResultVal ConvertScalingModeImpl(NintendoScaleMode mode) { + static Result ConvertScalingModeImpl(ConvertedScaleMode* out_scaling_mode, + NintendoScaleMode mode) { switch (mode) { case NintendoScaleMode::None: - return ConvertedScaleMode::None; + *out_scaling_mode = ConvertedScaleMode::None; + return ResultSuccess; case NintendoScaleMode::Freeze: - return ConvertedScaleMode::Freeze; + *out_scaling_mode = ConvertedScaleMode::Freeze; + return ResultSuccess; case NintendoScaleMode::ScaleToWindow: - return ConvertedScaleMode::ScaleToWindow; + *out_scaling_mode = ConvertedScaleMode::ScaleToWindow; + return ResultSuccess; case NintendoScaleMode::ScaleAndCrop: - return ConvertedScaleMode::ScaleAndCrop; + *out_scaling_mode = ConvertedScaleMode::ScaleAndCrop; + return ResultSuccess; case NintendoScaleMode::PreserveAspectRatio: - return ConvertedScaleMode::PreserveAspectRatio; + *out_scaling_mode = ConvertedScaleMode::PreserveAspectRatio; + return ResultSuccess; default: LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode); return ResultOperationFailed; From 83eee1d2266a1de374be0a8b2c0f2827f5e25bcf Mon Sep 17 00:00:00 2001 From: Liam Date: Sun, 16 Jul 2023 18:55:27 -0400 Subject: [PATCH 2/4] ssl: remove ResultVal use --- src/core/hle/service/sockets/nsd.cpp | 9 +- src/core/hle/service/ssl/ssl.cpp | 86 ++++++++++--------- src/core/hle/service/ssl/ssl_backend.h | 8 +- src/core/hle/service/ssl/ssl_backend_none.cpp | 2 +- .../hle/service/ssl/ssl_backend_openssl.cpp | 45 +++++----- .../hle/service/ssl/ssl_backend_schannel.cpp | 62 ++++++------- .../ssl/ssl_backend_securetransport.cpp | 39 ++++----- 7 files changed, 127 insertions(+), 124 deletions(-) diff --git a/src/core/hle/service/sockets/nsd.cpp b/src/core/hle/service/sockets/nsd.cpp index 5dfcaabb1..bac21752a 100644 --- a/src/core/hle/service/sockets/nsd.cpp +++ b/src/core/hle/service/sockets/nsd.cpp @@ -54,7 +54,7 @@ NSD::NSD(Core::System& system_, const char* name) : ServiceFramework{system_, na RegisterHandlers(functions); } -static ResultVal ResolveImpl(const std::string& fqdn_in) { +static std::string ResolveImpl(const std::string& fqdn_in) { // The real implementation makes various substitutions. // For now we just return the string as-is, which is good enough when not // connecting to real Nintendo servers. @@ -64,13 +64,10 @@ static ResultVal ResolveImpl(const std::string& fqdn_in) { static Result ResolveCommon(const std::string& fqdn_in, std::array& fqdn_out) { const auto res = ResolveImpl(fqdn_in); - if (res.Failed()) { - return res.Code(); - } - if (res->size() >= fqdn_out.size()) { + if (res.size() >= fqdn_out.size()) { return ResultOverflow; } - std::memcpy(fqdn_out.data(), res->c_str(), res->size() + 1); + std::memcpy(fqdn_out.data(), res.c_str(), res.size() + 1); return ResultSuccess; } diff --git a/src/core/hle/service/ssl/ssl.cpp b/src/core/hle/service/ssl/ssl.cpp index 9c96f9763..2cba9e5c9 100644 --- a/src/core/hle/service/ssl/ssl.cpp +++ b/src/core/hle/service/ssl/ssl.cpp @@ -4,6 +4,7 @@ #include "common/string_util.h" #include "core/core.h" +#include "core/hle/result.h" #include "core/hle/service/ipc_helpers.h" #include "core/hle/service/server_manager.h" #include "core/hle/service/service.h" @@ -141,12 +142,12 @@ private: bool did_set_host_name = false; bool did_handshake = false; - ResultVal SetSocketDescriptorImpl(s32 fd) { + Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) { LOG_DEBUG(Service_SSL, "called, fd={}", fd); ASSERT(!did_handshake); auto bsd = system.ServiceManager().GetService("bsd:u"); ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; }); - s32 ret_fd; + // Based on https://switchbrew.org/wiki/SSL_services#SetSocketDescriptor if (do_not_close_socket) { auto res = bsd->DuplicateSocketImpl(fd); @@ -156,9 +157,9 @@ private: } fd = *res; fd_to_close = fd; - ret_fd = fd; + *out_fd = fd; } else { - ret_fd = -1; + *out_fd = -1; } std::optional> sock = bsd->GetSocket(fd); if (!sock.has_value()) { @@ -167,7 +168,7 @@ private: } socket = std::move(*sock); backend->SetSocket(socket); - return ret_fd; + return ResultSuccess; } Result SetHostNameImpl(const std::string& hostname) { @@ -247,34 +248,36 @@ private: return ret; } - ResultVal> ReadImpl(size_t size) { + Result ReadImpl(std::vector* out_data, size_t size) { ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; }); - std::vector res(size); - ResultVal actual = backend->Read(res); - if (actual.Failed()) { - return actual.Code(); + size_t actual_size{}; + Result res = backend->Read(&actual_size, *out_data); + if (res != ResultSuccess) { + return res; } - res.resize(*actual); + out_data->resize(actual_size); return res; } - ResultVal WriteImpl(std::span data) { + Result WriteImpl(size_t* out_size, std::span data) { ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; }); - return backend->Write(data); + return backend->Write(out_size, data); } - ResultVal PendingImpl() { + Result PendingImpl(s32* out_pending) { LOG_WARNING(Service_SSL, "(STUBBED) called."); - return 0; + *out_pending = 0; + return ResultSuccess; } void SetSocketDescriptor(HLERequestContext& ctx) { IPC::RequestParser rp{ctx}; - const s32 fd = rp.Pop(); - const ResultVal res = SetSocketDescriptorImpl(fd); + const s32 in_fd = rp.Pop(); + s32 out_fd{-1}; + const Result res = SetSocketDescriptorImpl(&out_fd, in_fd); IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(res.Code()); - rb.Push(res.ValueOr(-1)); + rb.Push(res); + rb.Push(out_fd); } void SetHostName(HLERequestContext& ctx) { @@ -313,14 +316,15 @@ private: }; static_assert(sizeof(OutputParameters) == 0x8); - const Result res = DoHandshakeImpl(); + Result res = DoHandshakeImpl(); OutputParameters out{}; if (res == ResultSuccess) { - auto certs = backend->GetServerCerts(); - if (certs.Succeeded()) { - const std::vector certs_buf = SerializeServerCerts(*certs); + std::vector> certs; + res = backend->GetServerCerts(&certs); + if (res == ResultSuccess) { + const std::vector certs_buf = SerializeServerCerts(certs); ctx.WriteBuffer(certs_buf); - out.certs_count = static_cast(certs->size()); + out.certs_count = static_cast(certs.size()); out.certs_size = static_cast(certs_buf.size()); } } @@ -330,29 +334,32 @@ private: } void Read(HLERequestContext& ctx) { - const ResultVal> res = ReadImpl(ctx.GetWriteBufferSize()); + std::vector output_bytes; + const Result res = ReadImpl(&output_bytes, ctx.GetWriteBufferSize()); IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(res.Code()); - if (res.Succeeded()) { - rb.Push(static_cast(res->size())); - ctx.WriteBuffer(*res); + rb.Push(res); + if (res == ResultSuccess) { + rb.Push(static_cast(output_bytes.size())); + ctx.WriteBuffer(output_bytes); } else { rb.Push(static_cast(0)); } } void Write(HLERequestContext& ctx) { - const ResultVal res = WriteImpl(ctx.ReadBuffer()); + size_t write_size{0}; + const Result res = WriteImpl(&write_size, ctx.ReadBuffer()); IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(res.Code()); - rb.Push(static_cast(res.ValueOr(0))); + rb.Push(res); + rb.Push(static_cast(write_size)); } void Pending(HLERequestContext& ctx) { - const ResultVal res = PendingImpl(); + s32 pending_size{0}; + const Result res = PendingImpl(&pending_size); IPC::ResponseBuilder rb{ctx, 3}; - rb.Push(res.Code()); - rb.Push(res.ValueOr(0)); + rb.Push(res); + rb.Push(pending_size); } void SetSessionCacheMode(HLERequestContext& ctx) { @@ -438,13 +445,14 @@ private: void CreateConnection(HLERequestContext& ctx) { LOG_WARNING(Service_SSL, "called"); - auto backend_res = CreateSSLConnectionBackend(); + std::unique_ptr backend; + const Result res = CreateSSLConnectionBackend(&backend); IPC::ResponseBuilder rb{ctx, 2, 0, 1}; - rb.Push(backend_res.Code()); - if (backend_res.Succeeded()) { + rb.Push(res); + if (res == ResultSuccess) { rb.PushIpcInterface(system, ssl_version, shared_data, - std::move(*backend_res)); + std::move(backend)); } } diff --git a/src/core/hle/service/ssl/ssl_backend.h b/src/core/hle/service/ssl/ssl_backend.h index 409f4367c..a2ec8e694 100644 --- a/src/core/hle/service/ssl/ssl_backend.h +++ b/src/core/hle/service/ssl/ssl_backend.h @@ -35,11 +35,11 @@ public: virtual void SetSocket(std::shared_ptr socket) = 0; virtual Result SetHostName(const std::string& hostname) = 0; virtual Result DoHandshake() = 0; - virtual ResultVal Read(std::span data) = 0; - virtual ResultVal Write(std::span data) = 0; - virtual ResultVal>> GetServerCerts() = 0; + virtual Result Read(size_t* out_size, std::span data) = 0; + virtual Result Write(size_t* out_size, std::span data) = 0; + virtual Result GetServerCerts(std::vector>* out_certs) = 0; }; -ResultVal> CreateSSLConnectionBackend(); +Result CreateSSLConnectionBackend(std::unique_ptr* out_backend); } // namespace Service::SSL diff --git a/src/core/hle/service/ssl/ssl_backend_none.cpp b/src/core/hle/service/ssl/ssl_backend_none.cpp index 2f4f23c42..a7fafd0a3 100644 --- a/src/core/hle/service/ssl/ssl_backend_none.cpp +++ b/src/core/hle/service/ssl/ssl_backend_none.cpp @@ -7,7 +7,7 @@ namespace Service::SSL { -ResultVal> CreateSSLConnectionBackend() { +Result CreateSSLConnectionBackend(std::unique_ptr* out_backend) { LOG_ERROR(Service_SSL, "Can't create SSL connection because no SSL backend is available on this platform"); return ResultInternalError; diff --git a/src/core/hle/service/ssl/ssl_backend_openssl.cpp b/src/core/hle/service/ssl/ssl_backend_openssl.cpp index 6ca869dbf..b2dd37cd4 100644 --- a/src/core/hle/service/ssl/ssl_backend_openssl.cpp +++ b/src/core/hle/service/ssl/ssl_backend_openssl.cpp @@ -105,31 +105,30 @@ public: return ResultInternalError; } } - return HandleReturn("SSL_do_handshake", 0, ret).Code(); + return HandleReturn("SSL_do_handshake", 0, ret); } - ResultVal Read(std::span data) override { - size_t actual; - const int ret = SSL_read_ex(ssl, data.data(), data.size(), &actual); - return HandleReturn("SSL_read_ex", actual, ret); + Result Read(size_t* out_size, std::span data) override { + const int ret = SSL_read_ex(ssl, data.data(), data.size(), out_size); + return HandleReturn("SSL_read_ex", out_size, ret); } - ResultVal Write(std::span data) override { - size_t actual; - const int ret = SSL_write_ex(ssl, data.data(), data.size(), &actual); - return HandleReturn("SSL_write_ex", actual, ret); + Result Write(size_t* out_size, std::span data) override { + const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size); + return HandleReturn("SSL_write_ex", out_size, ret); } - ResultVal HandleReturn(const char* what, size_t actual, int ret) { + Result HandleReturn(const char* what, size_t* actual, int ret) { const int ssl_err = SSL_get_error(ssl, ret); CheckOpenSSLErrors(); switch (ssl_err) { case SSL_ERROR_NONE: - return actual; + return ResultSuccess; case SSL_ERROR_ZERO_RETURN: LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_ZERO_RETURN", what); // DoHandshake special-cases this, but for Read and Write: - return size_t(0); + *actual = 0; + return ResultSuccess; case SSL_ERROR_WANT_READ: LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_WANT_READ", what); return ResultWouldBlock; @@ -139,20 +138,20 @@ public: default: if (ssl_err == SSL_ERROR_SYSCALL && got_read_eof) { LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_SYSCALL because server hung up", what); - return size_t(0); + *actual = 0; + return ResultSuccess; } LOG_ERROR(Service_SSL, "{} => other SSL_get_error return value {}", what, ssl_err); return ResultInternalError; } } - ResultVal>> GetServerCerts() override { + Result GetServerCerts(std::vector>* out_certs) override { STACK_OF(X509)* chain = SSL_get_peer_cert_chain(ssl); if (!chain) { LOG_ERROR(Service_SSL, "SSL_get_peer_cert_chain returned nullptr"); return ResultInternalError; } - std::vector> ret; int count = sk_X509_num(chain); ASSERT(count >= 0); for (int i = 0; i < count; i++) { @@ -161,10 +160,10 @@ public: unsigned char* buf = nullptr; int len = i2d_X509(x509, &buf); ASSERT_OR_EXECUTE(len >= 0 && buf, { continue; }); - ret.emplace_back(buf, buf + len); + out_certs->emplace_back(buf, buf + len); OPENSSL_free(buf); } - return ret; + return ResultSuccess; } ~SSLConnectionBackendOpenSSL() { @@ -253,13 +252,13 @@ public: std::shared_ptr socket; }; -ResultVal> CreateSSLConnectionBackend() { +Result CreateSSLConnectionBackend(std::unique_ptr* out_backend) { auto conn = std::make_unique(); - const Result res = conn->Init(); - if (res.IsFailure()) { - return res; - } - return conn; + + R_TRY(conn->Init()); + + *out_backend = std::move(conn); + return ResultSuccess; } namespace { diff --git a/src/core/hle/service/ssl/ssl_backend_schannel.cpp b/src/core/hle/service/ssl/ssl_backend_schannel.cpp index d8074339a..bda12b761 100644 --- a/src/core/hle/service/ssl/ssl_backend_schannel.cpp +++ b/src/core/hle/service/ssl/ssl_backend_schannel.cpp @@ -299,21 +299,22 @@ public: return ResultSuccess; } - ResultVal Read(std::span data) override { + Result Read(size_t* out_size, std::span data) override { + *out_size = 0; if (handshake_state != HandshakeState::Connected) { LOG_ERROR(Service_SSL, "Called Read but we did not successfully handshake"); return ResultInternalError; } if (data.size() == 0 || got_read_eof) { - return size_t(0); + return ResultSuccess; } while (1) { if (!cleartext_read_buf.empty()) { - const size_t read_size = std::min(cleartext_read_buf.size(), data.size()); - std::memcpy(data.data(), cleartext_read_buf.data(), read_size); + *out_size = std::min(cleartext_read_buf.size(), data.size()); + std::memcpy(data.data(), cleartext_read_buf.data(), *out_size); cleartext_read_buf.erase(cleartext_read_buf.begin(), - cleartext_read_buf.begin() + read_size); - return read_size; + cleartext_read_buf.begin() + *out_size); + return ResultSuccess; } if (!ciphertext_read_buf.empty()) { SecBuffer empty{ @@ -366,7 +367,8 @@ public: case SEC_I_CONTEXT_EXPIRED: // Server hung up by sending close_notify. got_read_eof = true; - return size_t(0); + *out_size = 0; + return ResultSuccess; default: LOG_ERROR(Service_SSL, "DecryptMessage failed: {}", Common::NativeErrorToString(ret)); @@ -379,18 +381,21 @@ public: } if (ciphertext_read_buf.empty()) { got_read_eof = true; - return size_t(0); + *out_size = 0; + return ResultSuccess; } } } - ResultVal Write(std::span data) override { + Result Write(size_t* out_size, std::span data) override { + *out_size = 0; + if (handshake_state != HandshakeState::Connected) { LOG_ERROR(Service_SSL, "Called Write but we did not successfully handshake"); return ResultInternalError; } if (data.size() == 0) { - return size_t(0); + return ResultSuccess; } data = data.subspan(0, std::min(data.size(), stream_sizes.cbMaximumMessage)); if (!cleartext_write_buf.empty()) { @@ -402,7 +407,7 @@ public: LOG_ERROR(Service_SSL, "Called Write but buffer does not match previous buffer"); return ResultInternalError; } - return WriteAlreadyEncryptedData(); + return WriteAlreadyEncryptedData(out_size); } else { cleartext_write_buf.assign(data.begin(), data.end()); } @@ -448,21 +453,21 @@ public: tmp_data_buf.end()); ciphertext_write_buf.insert(ciphertext_write_buf.end(), trailer_buf.begin(), trailer_buf.end()); - return WriteAlreadyEncryptedData(); + return WriteAlreadyEncryptedData(out_size); } - ResultVal WriteAlreadyEncryptedData() { + Result WriteAlreadyEncryptedData(size_t* out_size) { const Result r = FlushCiphertextWriteBuf(); if (r != ResultSuccess) { return r; } // write buf is empty - const size_t cleartext_bytes_written = cleartext_write_buf.size(); + *out_size = cleartext_write_buf.size(); cleartext_write_buf.clear(); - return cleartext_bytes_written; + return ResultSuccess; } - ResultVal>> GetServerCerts() override { + Result GetServerCerts(std::vector>* out_certs) override { PCCERT_CONTEXT returned_cert = nullptr; const SECURITY_STATUS ret = QueryContextAttributes(&ctxt, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &returned_cert); @@ -473,16 +478,15 @@ public: return ResultInternalError; } PCCERT_CONTEXT some_cert = nullptr; - std::vector> certs; while ((some_cert = CertEnumCertificatesInStore(returned_cert->hCertStore, some_cert))) { - certs.emplace_back(static_cast(some_cert->pbCertEncoded), - static_cast(some_cert->pbCertEncoded) + - some_cert->cbCertEncoded); + out_certs->emplace_back(static_cast(some_cert->pbCertEncoded), + static_cast(some_cert->pbCertEncoded) + + some_cert->cbCertEncoded); } - std::reverse(certs.begin(), - certs.end()); // Windows returns certs in reverse order from what we want + std::reverse(out_certs->begin(), + out_certs->end()); // Windows returns certs in reverse order from what we want CertFreeCertificateContext(returned_cert); - return certs; + return ResultSuccess; } ~SSLConnectionBackendSchannel() { @@ -532,13 +536,13 @@ public: size_t read_buf_fill_size = 0; }; -ResultVal> CreateSSLConnectionBackend() { +Result CreateSSLConnectionBackend(std::unique_ptr* out_backend) { auto conn = std::make_unique(); - const Result res = conn->Init(); - if (res.IsFailure()) { - return res; - } - return conn; + + R_TRY(conn->Init()); + + *out_backend = std::move(conn); + return ResultSuccess; } } // namespace Service::SSL diff --git a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp index b3083cbad..5f9e6bef7 100644 --- a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp +++ b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp @@ -103,24 +103,20 @@ public: return HandleReturn("SSLHandshake", 0, status).Code(); } - ResultVal Read(std::span data) override { - size_t actual; - OSStatus status = SSLRead(context, data.data(), data.size(), &actual); - ; - return HandleReturn("SSLRead", actual, status); + Result Read(size_t* out_size, std::span data) override { + OSStatus status = SSLRead(context, data.data(), data.size(), &out_size); + return HandleReturn("SSLRead", out_size, status); } - ResultVal Write(std::span data) override { - size_t actual; - OSStatus status = SSLWrite(context, data.data(), data.size(), &actual); - ; - return HandleReturn("SSLWrite", actual, status); + Result Write(size_t* out_size, std::span data) override { + OSStatus status = SSLWrite(context, data.data(), data.size(), &out_size); + return HandleReturn("SSLWrite", out_size, status); } - ResultVal HandleReturn(const char* what, size_t actual, OSStatus status) { + Result HandleReturn(const char* what, size_t* actual, OSStatus status) { switch (status) { case 0: - return actual; + return ResultSuccess; case errSSLWouldBlock: return ResultWouldBlock; default: { @@ -136,22 +132,21 @@ public: } } - ResultVal>> GetServerCerts() override { + Result GetServerCerts(std::vector>* out_certs) override { CFReleaser trust; OSStatus status = SSLCopyPeerTrust(context, &trust.ptr); if (status) { LOG_ERROR(Service_SSL, "SSLCopyPeerTrust failed: {}", OSStatusToString(status)); return ResultInternalError; } - std::vector> ret; for (CFIndex i = 0, count = SecTrustGetCertificateCount(trust); i < count; i++) { SecCertificateRef cert = SecTrustGetCertificateAtIndex(trust, i); CFReleaser data(SecCertificateCopyData(cert)); ASSERT_OR_EXECUTE(data, { return ResultInternalError; }); const u8* ptr = CFDataGetBytePtr(data); - ret.emplace_back(ptr, ptr + CFDataGetLength(data)); + out_certs->emplace_back(ptr, ptr + CFDataGetLength(data)); } - return ret; + return ResultSuccess; } static OSStatus ReadCallback(SSLConnectionRef connection, void* data, size_t* dataLength) { @@ -210,13 +205,13 @@ private: std::shared_ptr socket; }; -ResultVal> CreateSSLConnectionBackend() { +Result CreateSSLConnectionBackend(std::unique_ptr* out_backend) { auto conn = std::make_unique(); - const Result res = conn->Init(); - if (res.IsFailure()) { - return res; - } - return conn; + + R_TRY(conn->Init()); + + *out_backend = std::move(conn); + return ResultSuccess; } } // namespace Service::SSL From 37b278a9a85fb934fa78ce4abf12a2c9df7d7112 Mon Sep 17 00:00:00 2001 From: Liam Date: Sat, 29 Jul 2023 20:43:34 -0400 Subject: [PATCH 3/4] general: fix incorrect conversions --- src/core/hle/service/filesystem/filesystem.cpp | 2 +- src/core/hle/service/ldr/ldr.cpp | 2 +- src/core/hle/service/ssl/ssl_backend_securetransport.cpp | 4 ++-- src/core/hle/service/vi/vi.cpp | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp index d9b569789..f59fa7fb1 100644 --- a/src/core/hle/service/filesystem/filesystem.cpp +++ b/src/core/hle/service/filesystem/filesystem.cpp @@ -57,7 +57,7 @@ Result VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size return FileSys::ERROR_PATH_NOT_FOUND; } - FileSys::EntryType entry_type; + FileSys::EntryType entry_type{}; if (GetEntryType(&entry_type, path) == ResultSuccess) { return FileSys::ERROR_PATH_ALREADY_EXISTS; } diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp index 95c5b7c8e..c73035c77 100644 --- a/src/core/hle/service/ldr/ldr.cpp +++ b/src/core/hle/service/ldr/ldr.cpp @@ -545,7 +545,7 @@ public: } // Map memory for the NRO - VAddr map_location; + VAddr map_location{}; const auto map_result{MapNro(&map_location, system.ApplicationProcess(), nro_address, nro_size, bss_address, bss_size, nro_size + bss_size)}; if (map_result != ResultSuccess) { diff --git a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp index 5f9e6bef7..370678f48 100644 --- a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp +++ b/src/core/hle/service/ssl/ssl_backend_securetransport.cpp @@ -104,12 +104,12 @@ public: } Result Read(size_t* out_size, std::span data) override { - OSStatus status = SSLRead(context, data.data(), data.size(), &out_size); + OSStatus status = SSLRead(context, data.data(), data.size(), out_size); return HandleReturn("SSLRead", out_size, status); } Result Write(size_t* out_size, std::span data) override { - OSStatus status = SSLWrite(context, data.data(), data.size(), &out_size); + OSStatus status = SSLWrite(context, data.data(), data.size(), out_size); return HandleReturn("SSLWrite", out_size, status); } diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp index 5998e786e..6bb02393c 100644 --- a/src/core/hle/service/vi/vi.cpp +++ b/src/core/hle/service/vi/vi.cpp @@ -697,7 +697,7 @@ private: IPC::ResponseBuilder rb{ctx, 2, 1}; rb.Push(ResultSuccess); - rb.PushCopyObjects(*vsync_event); + rb.PushCopyObjects(vsync_event); } void ConvertScalingMode(HLERequestContext& ctx) { From 1e394c6cdf1ab83c83477c19c0e736a95b86e8da Mon Sep 17 00:00:00 2001 From: Liam Date: Tue, 8 Aug 2023 16:12:04 -0400 Subject: [PATCH 4/4] fs: return result on null outputs --- .../hle/service/filesystem/filesystem.cpp | 28 ++++++++++++++++--- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp index f59fa7fb1..ac465d5a9 100644 --- a/src/core/hle/service/filesystem/filesystem.cpp +++ b/src/core/hle/service/filesystem/filesystem.cpp @@ -383,7 +383,12 @@ Result FileSystemController::CreateSaveData(FileSys::VirtualDir* out_save_data, return FileSys::ERROR_ENTITY_NOT_FOUND; } - *out_save_data = save_data_factory->Create(space, save_struct); + auto save_data = save_data_factory->Create(space, save_struct); + if (save_data == nullptr) { + return FileSys::ERROR_ENTITY_NOT_FOUND; + } + + *out_save_data = save_data; return ResultSuccess; } @@ -397,7 +402,12 @@ Result FileSystemController::OpenSaveData(FileSys::VirtualDir* out_save_data, return FileSys::ERROR_ENTITY_NOT_FOUND; } - *out_save_data = save_data_factory->Open(space, attribute); + auto save_data = save_data_factory->Open(space, attribute); + if (save_data == nullptr) { + return FileSys::ERROR_ENTITY_NOT_FOUND; + } + + *out_save_data = save_data; return ResultSuccess; } @@ -409,7 +419,12 @@ Result FileSystemController::OpenSaveDataSpace(FileSys::VirtualDir* out_save_dat return FileSys::ERROR_ENTITY_NOT_FOUND; } - *out_save_data_space = save_data_factory->GetSaveDataSpaceDirectory(space); + auto save_data_space = save_data_factory->GetSaveDataSpaceDirectory(space); + if (save_data_space == nullptr) { + return FileSys::ERROR_ENTITY_NOT_FOUND; + } + + *out_save_data_space = save_data_space; return ResultSuccess; } @@ -420,7 +435,12 @@ Result FileSystemController::OpenSDMC(FileSys::VirtualDir* out_sdmc) const { return FileSys::ERROR_SD_CARD_NOT_FOUND; } - *out_sdmc = sdmc_factory->Open(); + auto sdmc = sdmc_factory->Open(); + if (sdmc == nullptr) { + return FileSys::ERROR_SD_CARD_NOT_FOUND; + } + + *out_sdmc = sdmc; return ResultSuccess; }