mctaylors/suyu
1
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity

Merge pull request #11093 from liamwhite/result-ergonomics

Browse source 
core: remove ResultVal type
This commit is contained in:
bunnei 2023-08-09 21:24:31 -07:00 committed by GitHub
commit 9d3a293a4e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
39 changed files with 522 additions and 608 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

25
src/core/file_sys/romfs_factory.cpp
View file

@ -35,7 +35,7 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw_file) {
update_raw = std::move(update_raw_file); update_raw = std::move(update_raw_file);
} }
ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const { VirtualFile RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
if (!updatable) { if (!updatable) {
return file; return file;
} }
@ -45,12 +45,11 @@ ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_titl
return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw); return patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw);
} }
ResultVal<VirtualFile> 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); auto nca = content_provider.GetEntry(title_id, type);
if (nca == nullptr) { if (nca == nullptr) {
// TODO: Find the right error code to use here return nullptr;
return ResultUnknown;
} }
const PatchManager patch_manager{title_id, filesystem_controller, content_provider}; const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
@ -58,28 +57,20 @@ ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecor
return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type); return patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type);
} }
ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex( VirtualFile RomFSFactory::OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
u64 title_id, u8 program_index, ContentRecordType type) const { ContentRecordType type) const {
const auto res_title_id = GetBaseTitleIDWithProgramIndex(title_id, program_index); const auto res_title_id = GetBaseTitleIDWithProgramIndex(title_id, program_index);
return OpenPatchedRomFS(res_title_id, type); return OpenPatchedRomFS(res_title_id, type);
} }
ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, VirtualFile RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) const {
ContentRecordType type) const {
const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type); const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
if (res == nullptr) { if (res == nullptr) {
// TODO(DarkLordZach): Find the right error code to use here return nullptr;
return ResultUnknown;
} }
const auto romfs = res->GetRomFS(); return res->GetRomFS();
if (romfs == nullptr) {
// TODO(DarkLordZach): Find the right error code to use here
return ResultUnknown;
}
return romfs;
} }
std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage, std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,

12
src/core/file_sys/romfs_factory.h
View file

@ -41,13 +41,11 @@ public:
~RomFSFactory(); ~RomFSFactory();
void SetPackedUpdate(VirtualFile update_raw_file); void SetPackedUpdate(VirtualFile update_raw_file);
[[nodiscard]] ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const; [[nodiscard]] VirtualFile OpenCurrentProcess(u64 current_process_title_id) const;
[[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFS(u64 title_id, [[nodiscard]] VirtualFile OpenPatchedRomFS(u64 title_id, ContentRecordType type) const;
ContentRecordType type) const; [[nodiscard]] VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
[[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFSWithProgramIndex( ContentRecordType type) const;
u64 title_id, u8 program_index, ContentRecordType type) const; [[nodiscard]] VirtualFile Open(u64 title_id, StorageId storage, ContentRecordType type) const;
[[nodiscard]] ResultVal<VirtualFile> Open(u64 title_id, StorageId storage,
ContentRecordType type) const;
private: private:
[[nodiscard]] std::shared_ptr<NCA> GetEntry(u64 title_id, StorageId storage, [[nodiscard]] std::shared_ptr<NCA> GetEntry(u64 title_id, StorageId storage,

22
src/core/file_sys/savedata_factory.cpp
View file

@ -108,26 +108,16 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, VirtualDir save_director
SaveDataFactory::~SaveDataFactory() = default; SaveDataFactory::~SaveDataFactory() = default;
ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space, VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
const SaveDataAttribute& meta) const {
PrintSaveDataAttributeWarnings(meta); PrintSaveDataAttributeWarnings(meta);
const auto save_directory = const auto save_directory =
GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id); GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
auto out = dir->CreateDirectoryRelative(save_directory); return 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;
} }
ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
const SaveDataAttribute& meta) const {
const auto save_directory = const auto save_directory =
GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id); GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
@ -138,12 +128,6 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
return Create(space, meta); 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; return out;
} }

4
src/core/file_sys/savedata_factory.h
View file

@ -89,8 +89,8 @@ public:
explicit SaveDataFactory(Core::System& system_, VirtualDir save_directory_); explicit SaveDataFactory(Core::System& system_, VirtualDir save_directory_);
~SaveDataFactory(); ~SaveDataFactory();
ResultVal<VirtualDir> Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const; VirtualDir Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const; VirtualDir Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const;
VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const; VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;

2
src/core/file_sys/sdmc_factory.cpp
View file

@ -23,7 +23,7 @@ SDMCFactory::SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_)
SDMCFactory::~SDMCFactory() = default; SDMCFactory::~SDMCFactory() = default;
ResultVal<VirtualDir> SDMCFactory::Open() const { VirtualDir SDMCFactory::Open() const {
return sd_dir; return sd_dir;
} }

2
src/core/file_sys/sdmc_factory.h
View file

@ -18,7 +18,7 @@ public:
explicit SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_); explicit SDMCFactory(VirtualDir sd_dir_, VirtualDir sd_mod_dir_);
~SDMCFactory(); ~SDMCFactory();
ResultVal<VirtualDir> Open() const; VirtualDir Open() const;
VirtualDir GetSDMCModificationLoadRoot(u64 title_id) const; VirtualDir GetSDMCModificationLoadRoot(u64 title_id) const;
VirtualDir GetSDMCContentDirectory() const; VirtualDir GetSDMCContentDirectory() const;

2
src/core/hle/kernel/k_page_table.cpp
View file

@ -768,7 +768,7 @@ Result KPageTable::UnmapProcessMemory(KProcessAddress dst_addr, size_t size,
m_memory_block_slab_manager, num_allocator_blocks); m_memory_block_slab_manager, num_allocator_blocks);
R_TRY(allocator_result); 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. // Apply the memory block update.
m_memory_block_manager.Update(std::addressof(allocator), dst_addr, num_pages, m_memory_block_manager.Update(std::addressof(allocator), dst_addr, num_pages,

153
src/core/hle/result.h
View file

@ -283,159 +283,6 @@ private:
u32 description_end; 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<int> 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 <typename T>
class ResultVal {
public:
constexpr ResultVal() : expected{} {}
constexpr ResultVal(Result code) : expected{Common::Unexpected(code)} {}
constexpr ResultVal(ResultRange range) : expected{Common::Unexpected(range)} {}
template <typename U>
constexpr ResultVal(U&& val) : expected{std::forward<U>(val)} {}
template <typename... Args>
constexpr ResultVal(Args&&... args) : expected{std::in_place, std::forward<Args>(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 <typename U>
[[nodiscard]] constexpr T ValueOr(U&& v) const& {
return expected.value_or(v);
}
template <typename U>
[[nodiscard]] constexpr T ValueOr(U&& v) && {
return expected.value_or(v);
}
private:
// TODO (Morph): Replace this with C++23 std::expected.
Common::Expected<T, Result> 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<Result>(res).IsSuccess()) #define R_SUCCEEDED(res) (static_cast<Result>(res).IsSuccess())
#define R_FAILED(res) (static_cast<Result>(res).IsFailure()) #define R_FAILED(res) (static_cast<Result>(res).IsFailure())

11
src/core/hle/service/acc/acc.cpp
View file

@ -765,15 +765,16 @@ Result Module::Interface::InitializeApplicationInfoBase() {
// TODO(ogniK): This should be changed to reflect the target process for when we have multiple // 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 // processes emulated. As we don't actually have pid support we should assume we're just using
// our own process // our own process
const auto launch_property = Glue::ApplicationLaunchProperty launch_property{};
system.GetARPManager().GetLaunchProperty(system.GetApplicationProcessProgramID()); 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"); LOG_ERROR(Service_ACC, "Failed to get launch property");
return Account::ResultInvalidApplication; return Account::ResultInvalidApplication;
} }
switch (launch_property->base_game_storage_id) { switch (launch_property.base_game_storage_id) {
case FileSys::StorageId::GameCard: case FileSys::StorageId::GameCard:
application_info.application_type = ApplicationType::GameCard; application_info.application_type = ApplicationType::GameCard;
break; break;
@ -785,7 +786,7 @@ Result Module::Interface::InitializeApplicationInfoBase() {
break; break;
default: default:
LOG_ERROR(Service_ACC, "Invalid game storage ID! storage_id={}", 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; return Account::ResultInvalidApplication;
} }

26
src/core/hle/service/am/am.cpp
View file

@ -1578,11 +1578,13 @@ void IApplicationFunctions::EnsureSaveData(HLERequestContext& ctx) {
attribute.title_id = system.GetApplicationProcessProgramID(); attribute.title_id = system.GetApplicationProcessProgramID();
attribute.user_id = user_id; attribute.user_id = user_id;
attribute.type = FileSys::SaveDataType::SaveData; attribute.type = FileSys::SaveDataType::SaveData;
FileSys::VirtualDir save_data{};
const auto res = system.GetFileSystemController().CreateSaveData( const auto res = system.GetFileSystemController().CreateSaveData(
FileSys::SaveDataSpaceId::NandUser, attribute); &save_data, FileSys::SaveDataSpaceId::NandUser, attribute);
IPC::ResponseBuilder rb{ctx, 4}; IPC::ResponseBuilder rb{ctx, 4};
rb.Push(res.Code()); rb.Push(res);
rb.Push<u64>(0); rb.Push<u64>(0);
} }
@ -1667,26 +1669,30 @@ void IApplicationFunctions::GetDesiredLanguage(HLERequestContext& ctx) {
auto app_man = ns_am2->GetApplicationManagerInterface(); auto app_man = ns_am2->GetApplicationManagerInterface();
// Get desired application language // Get desired application language
const auto res_lang = app_man->GetApplicationDesiredLanguage(supported_languages); u8 desired_language{};
if (res_lang.Failed()) { const auto res_lang =
app_man->GetApplicationDesiredLanguage(&desired_language, supported_languages);
if (res_lang != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res_lang.Code()); rb.Push(res_lang);
return; return;
} }
// Convert to settings language code. // Convert to settings language code.
const auto res_code = app_man->ConvertApplicationLanguageToLanguageCode(*res_lang); u64 language_code{};
if (res_code.Failed()) { const auto res_code =
app_man->ConvertApplicationLanguageToLanguageCode(&language_code, desired_language);
if (res_code != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res_code.Code()); rb.Push(res_code);
return; 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}; IPC::ResponseBuilder rb{ctx, 4};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.Push(*res_code); rb.Push(language_code);
} }
void IApplicationFunctions::IsGamePlayRecordingSupported(HLERequestContext& ctx) { void IApplicationFunctions::IsGamePlayRecordingSupported(HLERequestContext& ctx) {

162
src/core/hle/service/filesystem/filesystem.cpp
View file

@ -57,8 +57,8 @@ Result VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size
return FileSys::ERROR_PATH_NOT_FOUND; return FileSys::ERROR_PATH_NOT_FOUND;
} }
const auto entry_type = GetEntryType(path); FileSys::EntryType entry_type{};
if (entry_type.Code() == ResultSuccess) { if (GetEntryType(&entry_type, path) == ResultSuccess) {
return FileSys::ERROR_PATH_ALREADY_EXISTS; return FileSys::ERROR_PATH_ALREADY_EXISTS;
} }
@ -210,8 +210,8 @@ Result VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
return ResultUnknown; return ResultUnknown;
} }
ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::string& path_, Result VfsDirectoryServiceWrapper::OpenFile(FileSys::VirtualFile* out_file,
FileSys::Mode mode) const { const std::string& path_, FileSys::Mode mode) const {
const std::string path(Common::FS::SanitizePath(path_)); const std::string path(Common::FS::SanitizePath(path_));
std::string_view npath = path; std::string_view npath = path;
while (!npath.empty() && (npath[0] == '/' || npath[0] == '\\')) { while (!npath.empty() && (npath[0] == '/' || npath[0] == '\\')) {
@ -224,50 +224,68 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
} }
if (mode == FileSys::Mode::Append) { if (mode == FileSys::Mode::Append) {
return std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize()); *out_file = std::make_shared<FileSys::OffsetVfsFile>(file, 0, file->GetSize());
} else {
*out_file = file;
} }
return file; return ResultSuccess;
} }
ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) { Result VfsDirectoryServiceWrapper::OpenDirectory(FileSys::VirtualDir* out_directory,
const std::string& path_) {
std::string path(Common::FS::SanitizePath(path_)); std::string path(Common::FS::SanitizePath(path_));
auto dir = GetDirectoryRelativeWrapped(backing, path); auto dir = GetDirectoryRelativeWrapped(backing, path);
if (dir == nullptr) { if (dir == nullptr) {
// TODO(DarkLordZach): Find a better error code for this // TODO(DarkLordZach): Find a better error code for this
return FileSys::ERROR_PATH_NOT_FOUND; return FileSys::ERROR_PATH_NOT_FOUND;
} }
return dir; *out_directory = dir;
return ResultSuccess;
} }
ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType( Result VfsDirectoryServiceWrapper::GetEntryType(FileSys::EntryType* out_entry_type,
const std::string& path_) const { const std::string& path_) const {
std::string path(Common::FS::SanitizePath(path_)); std::string path(Common::FS::SanitizePath(path_));
auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(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<FileSys::FileTimeStampRaw> VfsDirectoryServiceWrapper::GetFileTimeStampRaw(
const std::string& path) const {
auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
if (dir == nullptr) { if (dir == nullptr) {
return FileSys::ERROR_PATH_NOT_FOUND; 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 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_} {} 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)); romfs_factory->SetPackedUpdate(std::move(update_raw));
} }
ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess() const { FileSys::VirtualFile FileSystemController::OpenRomFSCurrentProcess() const {
LOG_TRACE(Service_FS, "Opening RomFS for current process"); LOG_TRACE(Service_FS, "Opening RomFS for current process");
if (romfs_factory == nullptr) { if (romfs_factory == nullptr) {
// TODO(bunnei): Find a better error code for this return nullptr;
return ResultUnknown;
} }
return romfs_factory->OpenCurrentProcess(system.GetApplicationProcessProgramID()); return romfs_factory->OpenCurrentProcess(system.GetApplicationProcessProgramID());
} }
ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFS( FileSys::VirtualFile FileSystemController::OpenPatchedRomFS(u64 title_id,
u64 title_id, FileSys::ContentRecordType type) const { FileSys::ContentRecordType type) const {
LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}", title_id); LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}", title_id);
if (romfs_factory == nullptr) { if (romfs_factory == nullptr) {
// TODO: Find a better error code for this return nullptr;
return ResultUnknown;
} }
return romfs_factory->OpenPatchedRomFS(title_id, type); return romfs_factory->OpenPatchedRomFS(title_id, type);
} }
ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFSWithProgramIndex( FileSys::VirtualFile FileSystemController::OpenPatchedRomFSWithProgramIndex(
u64 title_id, u8 program_index, FileSys::ContentRecordType type) const { 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, LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}, program_index={}", title_id,
program_index); program_index);
if (romfs_factory == nullptr) { if (romfs_factory == nullptr) {
// TODO: Find a better error code for this return nullptr;
return ResultUnknown;
} }
return romfs_factory->OpenPatchedRomFSWithProgramIndex(title_id, program_index, type); return romfs_factory->OpenPatchedRomFSWithProgramIndex(title_id, program_index, type);
} }
ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS( FileSys::VirtualFile FileSystemController::OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
u64 title_id, FileSys::StorageId storage_id, FileSys::ContentRecordType type) const { FileSys::ContentRecordType type) const {
LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}", LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
title_id, storage_id, type); title_id, storage_id, type);
if (romfs_factory == nullptr) { if (romfs_factory == nullptr) {
// TODO(bunnei): Find a better error code for this return nullptr;
return ResultUnknown;
} }
return romfs_factory->Open(title_id, storage_id, type); return romfs_factory->Open(title_id, storage_id, type);
} }
ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData( Result FileSystemController::CreateSaveData(FileSys::VirtualDir* out_save_data,
FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const { FileSys::SaveDataSpaceId space,
const FileSys::SaveDataAttribute& save_struct) const {
LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}", space, LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}", space,
save_struct.DebugInfo()); save_struct.DebugInfo());
@ -368,11 +383,18 @@ ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
return FileSys::ERROR_ENTITY_NOT_FOUND; return FileSys::ERROR_ENTITY_NOT_FOUND;
} }
return 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;
} }
ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData( Result FileSystemController::OpenSaveData(FileSys::VirtualDir* out_save_data,
FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& attribute) const { FileSys::SaveDataSpaceId space,
const FileSys::SaveDataAttribute& attribute) const {
LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}", space, LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}", space,
attribute.DebugInfo()); attribute.DebugInfo());
@ -380,32 +402,50 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
return FileSys::ERROR_ENTITY_NOT_FOUND; return FileSys::ERROR_ENTITY_NOT_FOUND;
} }
return 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;
} }
ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace( Result FileSystemController::OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space,
FileSys::SaveDataSpaceId space) const { FileSys::SaveDataSpaceId space) const {
LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", space); LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", space);
if (save_data_factory == nullptr) { if (save_data_factory == nullptr) {
return FileSys::ERROR_ENTITY_NOT_FOUND; return FileSys::ERROR_ENTITY_NOT_FOUND;
} }
return 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;
} }
ResultVal<FileSys::VirtualDir> FileSystemController::OpenSDMC() const { Result FileSystemController::OpenSDMC(FileSys::VirtualDir* out_sdmc) const {
LOG_TRACE(Service_FS, "Opening SDMC"); LOG_TRACE(Service_FS, "Opening SDMC");
if (sdmc_factory == nullptr) { if (sdmc_factory == nullptr) {
return FileSys::ERROR_SD_CARD_NOT_FOUND; return FileSys::ERROR_SD_CARD_NOT_FOUND;
} }
return sdmc_factory->Open(); auto sdmc = sdmc_factory->Open();
if (sdmc == nullptr) {
return FileSys::ERROR_SD_CARD_NOT_FOUND;
}
*out_sdmc = sdmc;
return ResultSuccess;
} }
ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition( Result FileSystemController::OpenBISPartition(FileSys::VirtualDir* out_bis_partition,
FileSys::BisPartitionId id) const { FileSys::BisPartitionId id) const {
LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", id); LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", id);
if (bis_factory == nullptr) { if (bis_factory == nullptr) {
@ -417,11 +457,12 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
return FileSys::ERROR_INVALID_ARGUMENT; return FileSys::ERROR_INVALID_ARGUMENT;
} }
return part; *out_bis_partition = part;
return ResultSuccess;
} }
ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage( Result FileSystemController::OpenBISPartitionStorage(
FileSys::BisPartitionId id) const { FileSys::VirtualFile* out_bis_partition_storage, FileSys::BisPartitionId id) const {
LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", id); LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", id);
if (bis_factory == nullptr) { if (bis_factory == nullptr) {
@ -433,7 +474,8 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
return FileSys::ERROR_INVALID_ARGUMENT; return FileSys::ERROR_INVALID_ARGUMENT;
} }
return part; *out_bis_partition_storage = part;
return ResultSuccess;
} }
u64 FileSystemController::GetFreeSpaceSize(FileSys::StorageId id) const { u64 FileSystemController::GetFreeSpaceSize(FileSys::StorageId id) const {

43
src/core/hle/service/filesystem/filesystem.h
View file

@ -64,21 +64,24 @@ public:
Result RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory); Result RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
void SetPackedUpdate(FileSys::VirtualFile update_raw); void SetPackedUpdate(FileSys::VirtualFile update_raw);
ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() const; FileSys::VirtualFile OpenRomFSCurrentProcess() const;
ResultVal<FileSys::VirtualFile> OpenPatchedRomFS(u64 title_id, FileSys::VirtualFile OpenPatchedRomFS(u64 title_id, FileSys::ContentRecordType type) const;
FileSys::ContentRecordType type) const; FileSys::VirtualFile OpenPatchedRomFSWithProgramIndex(u64 title_id, u8 program_index,
ResultVal<FileSys::VirtualFile> OpenPatchedRomFSWithProgramIndex( FileSys::ContentRecordType type) const;
u64 title_id, u8 program_index, FileSys::ContentRecordType type) const; FileSys::VirtualFile OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id, FileSys::ContentRecordType type) const;
FileSys::ContentRecordType type) const;
ResultVal<FileSys::VirtualDir> CreateSaveData( Result CreateSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space,
FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const; const FileSys::SaveDataAttribute& save_struct) const;
ResultVal<FileSys::VirtualDir> OpenSaveData( Result OpenSaveData(FileSys::VirtualDir* out_save_data, FileSys::SaveDataSpaceId space,
FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const; const FileSys::SaveDataAttribute& save_struct) const;
ResultVal<FileSys::VirtualDir> OpenSaveDataSpace(FileSys::SaveDataSpaceId space) const; Result OpenSaveDataSpace(FileSys::VirtualDir* out_save_data_space,
ResultVal<FileSys::VirtualDir> OpenSDMC() const; FileSys::SaveDataSpaceId space) const;
ResultVal<FileSys::VirtualDir> OpenBISPartition(FileSys::BisPartitionId id) const; Result OpenSDMC(FileSys::VirtualDir* out_sdmc) const;
ResultVal<FileSys::VirtualFile> OpenBISPartitionStorage(FileSys::BisPartitionId id) 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 GetFreeSpaceSize(FileSys::StorageId id) const;
u64 GetTotalSpaceSize(FileSys::StorageId id) const; u64 GetTotalSpaceSize(FileSys::StorageId id) const;
@ -224,26 +227,28 @@ public:
* @param mode Mode to open the file with * @param mode Mode to open the file with
* @return Opened file, or error code * @return Opened file, or error code
*/ */
ResultVal<FileSys::VirtualFile> 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 * Open a directory specified by its path
* @param path Path relative to the archive * @param path Path relative to the archive
* @return Opened directory, or error code * @return Opened directory, or error code
*/ */
ResultVal<FileSys::VirtualDir> OpenDirectory(const std::string& path); Result OpenDirectory(FileSys::VirtualDir* out_directory, const std::string& path);
/** /**
* Get the type of the specified path * Get the type of the specified path
* @return The type of the specified path or error code * @return The type of the specified path or error code
*/ */
ResultVal<FileSys::EntryType> 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 * Get the timestamp of the specified path
* @return The timestamp of the specified path or error code * @return The timestamp of the specified path or error code
*/ */
ResultVal<FileSys::FileTimeStampRaw> GetFileTimeStampRaw(const std::string& path) const; Result GetFileTimeStampRaw(FileSys::FileTimeStampRaw* out_time_stamp_raw,
const std::string& path) const;
private: private:
FileSys::VirtualDir backing; FileSys::VirtualDir backing;

75
src/core/hle/service/filesystem/fsp_srv.cpp
View file

@ -419,14 +419,15 @@ public:
LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode); LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode);
auto result = backend.OpenFile(name, mode); FileSys::VirtualFile vfs_file{};
if (result.Failed()) { auto result = backend.OpenFile(&vfs_file, name, mode);
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result.Code()); rb.Push(result);
return; return;
} }
auto file = std::make_shared<IFile>(system, result.Unwrap()); auto file = std::make_shared<IFile>(system, vfs_file);
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -444,14 +445,15 @@ public:
LOG_DEBUG(Service_FS, "called. directory={}, filter={}", name, filter_flags); LOG_DEBUG(Service_FS, "called. directory={}, filter={}", name, filter_flags);
auto result = backend.OpenDirectory(name); FileSys::VirtualDir vfs_dir{};
if (result.Failed()) { auto result = backend.OpenDirectory(&vfs_dir, name);
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result.Code()); rb.Push(result);
return; return;
} }
auto directory = std::make_shared<IDirectory>(system, result.Unwrap()); auto directory = std::make_shared<IDirectory>(system, vfs_dir);
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -464,16 +466,17 @@ public:
LOG_DEBUG(Service_FS, "called. file={}", name); LOG_DEBUG(Service_FS, "called. file={}", name);
auto result = backend.GetEntryType(name); FileSys::EntryType vfs_entry_type{};
if (result.Failed()) { auto result = backend.GetEntryType(&vfs_entry_type, name);
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result.Code()); rb.Push(result);
return; return;
} }
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.Push<u32>(static_cast<u32>(*result)); rb.Push<u32>(static_cast<u32>(vfs_entry_type));
} }
void Commit(HLERequestContext& ctx) { void Commit(HLERequestContext& ctx) {
@ -505,16 +508,17 @@ public:
LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name); LOG_WARNING(Service_FS, "(Partial Implementation) called. file={}", name);
auto result = backend.GetFileTimeStampRaw(name); FileSys::FileTimeStampRaw vfs_timestamp{};
if (result.Failed()) { auto result = backend.GetFileTimeStampRaw(&vfs_timestamp, name);
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result.Code()); rb.Push(result);
return; return;
} }
IPC::ResponseBuilder rb{ctx, 10}; IPC::ResponseBuilder rb{ctx, 10};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.PushRaw(*result); rb.PushRaw(vfs_timestamp);
} }
private: private:
@ -572,14 +576,15 @@ private:
} }
void FindAllSaves(FileSys::SaveDataSpaceId space) { 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); LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space);
return; return;
} }
for (const auto& type : (*save_root)->GetSubdirectories()) { for (const auto& type : save_root->GetSubdirectories()) {
if (type->GetName() == "save") { if (type->GetName() == "save") {
for (const auto& save_id : type->GetSubdirectories()) { for (const auto& save_id : type->GetSubdirectories()) {
for (const auto& user_id : save_id->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) { void FSP_SRV::OpenSdCardFileSystem(HLERequestContext& ctx) {
LOG_DEBUG(Service_FS, "called"); LOG_DEBUG(Service_FS, "called");
auto filesystem = FileSys::VirtualDir sdmc_dir{};
std::make_shared<IFileSystem>(system, fsc.OpenSDMC().Unwrap(), fsc.OpenSDMC(&sdmc_dir);
SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard));
auto filesystem = std::make_shared<IFileSystem>(
system, sdmc_dir, SizeGetter::FromStorageId(fsc, FileSys::StorageId::SdCard));
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(ResultSuccess); 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(), LOG_DEBUG(Service_FS, "called save_struct = {}, uid = {:016X}{:016X}", save_struct.DebugInfo(),
uid[1], uid[0]); 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}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -874,8 +882,9 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
LOG_INFO(Service_FS, "called."); LOG_INFO(Service_FS, "called.");
auto dir = fsc.OpenSaveData(parameters.space_id, parameters.attribute); FileSys::VirtualDir dir{};
if (dir.Failed()) { auto result = fsc.OpenSaveData(&dir, parameters.space_id, parameters.attribute);
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2, 0, 0}; IPC::ResponseBuilder rb{ctx, 2, 0, 0};
rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND); rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
return; return;
@ -899,8 +908,8 @@ void FSP_SRV::OpenSaveDataFileSystem(HLERequestContext& ctx) {
ASSERT(false); ASSERT(false);
} }
auto filesystem = std::make_shared<IFileSystem>(system, std::move(dir.Unwrap()), auto filesystem =
SizeGetter::FromStorageId(fsc, id)); std::make_shared<IFileSystem>(system, std::move(dir), SizeGetter::FromStorageId(fsc, id));
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -970,7 +979,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) {
if (!romfs) { if (!romfs) {
auto current_romfs = fsc.OpenRomFSCurrentProcess(); auto current_romfs = fsc.OpenRomFSCurrentProcess();
if (current_romfs.Failed()) { if (!current_romfs) {
// TODO (bunnei): Find the right error code to use here // TODO (bunnei): Find the right error code to use here
LOG_CRITICAL(Service_FS, "no file system interface available!"); LOG_CRITICAL(Service_FS, "no file system interface available!");
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
@ -978,7 +987,7 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(HLERequestContext& ctx) {
return; return;
} }
romfs = current_romfs.Unwrap(); romfs = current_romfs;
} }
auto storage = std::make_shared<IStorage>(system, romfs); auto storage = std::make_shared<IStorage>(system, romfs);
@ -999,7 +1008,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
auto data = fsc.OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data); auto data = fsc.OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
if (data.Failed()) { if (!data) {
const auto archive = FileSys::SystemArchive::SynthesizeSystemArchive(title_id); const auto archive = FileSys::SystemArchive::SynthesizeSystemArchive(title_id);
if (archive != nullptr) { if (archive != nullptr) {
@ -1021,7 +1030,7 @@ void FSP_SRV::OpenDataStorageByDataId(HLERequestContext& ctx) {
const FileSys::PatchManager pm{title_id, fsc, content_provider}; const FileSys::PatchManager pm{title_id, fsc, content_provider};
auto storage = std::make_shared<IStorage>( auto storage = std::make_shared<IStorage>(
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}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -1051,7 +1060,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
fsc.OpenPatchedRomFSWithProgramIndex(system.GetApplicationProcessProgramID(), program_index, fsc.OpenPatchedRomFSWithProgramIndex(system.GetApplicationProcessProgramID(), program_index,
FileSys::ContentRecordType::Program); FileSys::ContentRecordType::Program);
if (patched_romfs.Failed()) { if (!patched_romfs) {
// TODO: Find the right error code to use here // TODO: Find the right error code to use here
LOG_ERROR(Service_FS, "could not open storage with program_index={}", program_index); LOG_ERROR(Service_FS, "could not open storage with program_index={}", program_index);
@ -1060,7 +1069,7 @@ void FSP_SRV::OpenDataStorageWithProgramIndex(HLERequestContext& ctx) {
return; return;
} }
auto storage = std::make_shared<IStorage>(system, std::move(patched_romfs.Unwrap())); auto storage = std::make_shared<IStorage>(system, std::move(patched_romfs));
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);

36
src/core/hle/service/glue/arp.cpp
View file

@ -65,18 +65,19 @@ void ARP_R::GetApplicationLaunchProperty(HLERequestContext& ctx) {
return; 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!"); LOG_ERROR(Service_ARP, "Failed to get launch property!");
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res.Code()); rb.Push(res);
return; return;
} }
IPC::ResponseBuilder rb{ctx, 6}; IPC::ResponseBuilder rb{ctx, 6};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.PushRaw(*res); rb.PushRaw(launch_property);
} }
void ARP_R::GetApplicationLaunchPropertyWithApplicationId(HLERequestContext& ctx) { 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); 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!"); LOG_ERROR(Service_ARP, "Failed to get launch property!");
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res.Code()); rb.Push(res);
return; return;
} }
IPC::ResponseBuilder rb{ctx, 6}; IPC::ResponseBuilder rb{ctx, 6};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.PushRaw(*res); rb.PushRaw(launch_property);
} }
void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) { void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) {
@ -113,16 +115,17 @@ void ARP_R::GetApplicationControlProperty(HLERequestContext& ctx) {
return; return;
} }
const auto res = manager.GetControlProperty(*title_id); std::vector<u8> 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!"); LOG_ERROR(Service_ARP, "Failed to get control property!");
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res.Code()); rb.Push(res);
return; return;
} }
ctx.WriteBuffer(*res); ctx.WriteBuffer(nacp_data);
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
@ -134,16 +137,17 @@ void ARP_R::GetApplicationControlPropertyWithApplicationId(HLERequestContext& ct
LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id); LOG_DEBUG(Service_ARP, "called, title_id={:016X}", title_id);
const auto res = manager.GetControlProperty(title_id); std::vector<u8> 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!"); LOG_ERROR(Service_ARP, "Failed to get control property!");
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res.Code()); rb.Push(res);
return; return;
} }
ctx.WriteBuffer(*res); ctx.WriteBuffer(nacp_data);
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);

11
src/core/hle/service/glue/glue_manager.cpp
View file

@ -15,7 +15,8 @@ ARPManager::ARPManager() = default;
ARPManager::~ARPManager() = default; ARPManager::~ARPManager() = default;
ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id) const { Result ARPManager::GetLaunchProperty(ApplicationLaunchProperty* out_launch_property,
u64 title_id) const {
if (title_id == 0) { if (title_id == 0) {
return Glue::ResultInvalidProcessId; return Glue::ResultInvalidProcessId;
} }
@ -25,10 +26,11 @@ ResultVal<ApplicationLaunchProperty> ARPManager::GetLaunchProperty(u64 title_id)
return Glue::ResultProcessIdNotRegistered; return Glue::ResultProcessIdNotRegistered;
} }
return iter->second.launch; *out_launch_property = iter->second.launch;
return ResultSuccess;
} }
ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const { Result ARPManager::GetControlProperty(std::vector<u8>* out_control_property, u64 title_id) const {
if (title_id == 0) { if (title_id == 0) {
return Glue::ResultInvalidProcessId; return Glue::ResultInvalidProcessId;
} }
@ -38,7 +40,8 @@ ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
return Glue::ResultProcessIdNotRegistered; return Glue::ResultProcessIdNotRegistered;
} }
return iter->second.control; *out_control_property = iter->second.control;
return ResultSuccess;
} }
Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch, Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,

4
src/core/hle/service/glue/glue_manager.h
View file

@ -32,12 +32,12 @@ public:
// Returns the ApplicationLaunchProperty corresponding to the provided title ID if it was // Returns the ApplicationLaunchProperty corresponding to the provided title ID if it was
// previously registered, otherwise ResultProcessIdNotRegistered if it was never registered or // previously registered, otherwise ResultProcessIdNotRegistered if it was never registered or
// ResultInvalidProcessId if the title ID is 0. // ResultInvalidProcessId if the title ID is 0.
ResultVal<ApplicationLaunchProperty> 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 // 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 // the provided title ID if it was previously registered, otherwise ResultProcessIdNotRegistered
// if it was never registered or ResultInvalidProcessId if the title ID is 0. // if it was never registered or ResultInvalidProcessId if the title ID is 0.
ResultVal<std::vector<u8>> GetControlProperty(u64 title_id) const; Result GetControlProperty(std::vector<u8>* out_control_property, u64 title_id) const;
// Adds a new entry to the internal database with the provided parameters, returning // 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 // ResultProcessIdNotRegistered if attempting to re-register a title ID without an intermediate

46
src/core/hle/service/ldr/ldr.cpp
View file

@ -357,7 +357,8 @@ public:
return ResultSuccess; return ResultSuccess;
} }
ResultVal<VAddr> 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()}; auto& page_table{process->GetPageTable()};
VAddr addr{}; VAddr addr{};
@ -372,20 +373,21 @@ public:
R_TRY(result); R_TRY(result);
if (ValidateRegionForMap(page_table, addr, size)) { if (ValidateRegionForMap(page_table, addr, size)) {
return addr; *out_map_location = addr;
return ResultSuccess;
} }
} }
return ERROR_INSUFFICIENT_ADDRESS_SPACE; return ERROR_INSUFFICIENT_ADDRESS_SPACE;
} }
ResultVal<VAddr> MapNro(Kernel::KProcess* process, VAddr nro_addr, std::size_t nro_size, Result MapNro(VAddr* out_map_location, Kernel::KProcess* process, VAddr nro_addr,
VAddr bss_addr, std::size_t bss_size, std::size_t size) { 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++) { for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
auto& page_table{process->GetPageTable()}; auto& page_table{process->GetPageTable()};
VAddr addr{}; VAddr addr{};
CASCADE_RESULT(addr, MapProcessCodeMemory(process, nro_addr, nro_size)); R_TRY(MapProcessCodeMemory(&addr, process, nro_addr, nro_size));
if (bss_size) { if (bss_size) {
auto block_guard = detail::ScopeExit([&] { auto block_guard = detail::ScopeExit([&] {
@ -411,7 +413,8 @@ public:
} }
if (ValidateRegionForMap(page_table, addr, size)) { 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, CopyCode(nro_addr + nro_header.segment_headers[DATA_INDEX].memory_offset, data_start,
nro_header.segment_headers[DATA_INDEX].memory_size); 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)); 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)); ro_start, data_start - ro_start, Kernel::Svc::MemoryPermission::Read));
return process->GetPageTable().SetProcessMemoryPermission( return process->GetPageTable().SetProcessMemoryPermission(
@ -542,31 +545,32 @@ public:
} }
// Map memory for the NRO // Map memory for the NRO
const auto map_result{MapNro(system.ApplicationProcess(), nro_address, nro_size, VAddr map_location{};
bss_address, bss_size, nro_size + bss_size)}; const auto map_result{MapNro(&map_location, system.ApplicationProcess(), nro_address,
if (map_result.Failed()) { nro_size, bss_address, bss_size, nro_size + bss_size)};
if (map_result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(map_result.Code()); rb.Push(map_result);
} }
// Load the NRO into the mapped memory // Load the NRO into the mapped memory
if (const auto result{ if (const auto result{
LoadNro(system.ApplicationProcess(), header, nro_address, *map_result)}; LoadNro(system.ApplicationProcess(), header, nro_address, map_location)};
result.IsError()) { result.IsError()) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(map_result.Code()); rb.Push(result);
} }
// Track the loaded NRO // Track the loaded NRO
nro.insert_or_assign(*map_result, nro.insert_or_assign(map_location,
NROInfo{hash, *map_result, nro_size, bss_address, bss_size, NROInfo{hash, map_location, nro_size, bss_address, bss_size,
header.segment_headers[TEXT_INDEX].memory_size, header.segment_headers[TEXT_INDEX].memory_size,
header.segment_headers[RO_INDEX].memory_size, header.segment_headers[RO_INDEX].memory_size,
header.segment_headers[DATA_INDEX].memory_size, nro_address}); header.segment_headers[DATA_INDEX].memory_size, nro_address});
IPC::ResponseBuilder rb{ctx, 4}; IPC::ResponseBuilder rb{ctx, 4};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.Push(*map_result); rb.Push(map_location);
} }
Result UnmapNro(const NROInfo& info) { Result UnmapNro(const NROInfo& info) {
@ -574,19 +578,19 @@ public:
auto& page_table{system.ApplicationProcess()->GetPageTable()}; auto& page_table{system.ApplicationProcess()->GetPageTable()};
if (info.bss_size != 0) { 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.nro_address + info.text_size + info.ro_size + info.data_size, info.bss_address,
info.bss_size, Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); 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.nro_address + info.text_size + info.ro_size,
info.src_addr + info.text_size + info.ro_size, info.data_size, info.src_addr + info.text_size + info.ro_size, info.data_size,
Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); 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, info.nro_address + info.text_size, info.src_addr + info.text_size, info.ro_size,
Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
CASCADE_CODE(page_table.UnmapCodeMemory( R_TRY(page_table.UnmapCodeMemory(
info.nro_address, info.src_addr, info.text_size, info.nro_address, info.src_addr, info.text_size,
Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange)); Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange));
return ResultSuccess; return ResultSuccess;

34
src/core/hle/service/mii/mii.cpp
View file

@ -101,20 +101,14 @@ private:
LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag); LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
const auto result{manager.GetDefault(source_flag)}; const auto default_miis{manager.GetDefault(source_flag)};
if (result.Failed()) { if (default_miis.size() > 0) {
IPC::ResponseBuilder rb{ctx, 2}; ctx.WriteBuffer(SerializeArray(default_miis));
rb.Push(result.Code());
return;
}
if (result->size() > 0) {
ctx.WriteBuffer(SerializeArray(*result));
} }
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.Push<u32>(static_cast<u32>(result->size())); rb.Push<u32>(static_cast<u32>(default_miis.size()));
} }
void Get1(HLERequestContext& ctx) { void Get1(HLERequestContext& ctx) {
@ -123,15 +117,10 @@ private:
LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag); LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
const auto result{manager.GetDefault(source_flag)}; const auto default_miis{manager.GetDefault(source_flag)};
if (result.Failed()) {
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result.Code());
return;
}
std::vector<CharInfo> values; std::vector<CharInfo> values;
for (const auto& element : *result) { for (const auto& element : default_miis) {
values.emplace_back(element.info); values.emplace_back(element.info);
} }
@ -139,7 +128,7 @@ private:
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.Push<u32>(static_cast<u32>(result->size())); rb.Push<u32>(static_cast<u32>(default_miis.size()));
} }
void UpdateLatest(HLERequestContext& ctx) { void UpdateLatest(HLERequestContext& ctx) {
@ -149,16 +138,17 @@ private:
LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag); LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
const auto result{manager.UpdateLatest(info, source_flag)}; CharInfo new_char_info{};
if (result.Failed()) { const auto result{manager.UpdateLatest(&new_char_info, info, source_flag)};
if (result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result.Code()); rb.Push(result);
return; return;
} }
IPC::ResponseBuilder rb{ctx, 2 + sizeof(CharInfo) / sizeof(u32)}; IPC::ResponseBuilder rb{ctx, 2 + sizeof(CharInfo) / sizeof(u32)};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.PushRaw<CharInfo>(*result); rb.PushRaw<CharInfo>(new_char_info);
} }
void BuildRandom(HLERequestContext& ctx) { void BuildRandom(HLERequestContext& ctx) {

5
src/core/hle/service/mii/mii_manager.cpp
View file

@ -409,8 +409,7 @@ u32 MiiManager::GetCount(SourceFlag source_flag) const {
return static_cast<u32>(count); return static_cast<u32>(count);
} }
ResultVal<CharInfo> MiiManager::UpdateLatest([[maybe_unused]] const CharInfo& info, Result MiiManager::UpdateLatest(CharInfo* out_info, const CharInfo& info, SourceFlag source_flag) {
SourceFlag source_flag) {
if ((source_flag & SourceFlag::Database) == SourceFlag::None) { if ((source_flag & SourceFlag::Database) == SourceFlag::None) {
return ERROR_CANNOT_FIND_ENTRY; return ERROR_CANNOT_FIND_ENTRY;
} }
@ -672,7 +671,7 @@ bool MiiManager::ValidateV3Info(const Ver3StoreData& mii_v3) const {
return is_valid; return is_valid;
} }
ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_flag) { std::vector<MiiInfoElement> MiiManager::GetDefault(SourceFlag source_flag) {
std::vector<MiiInfoElement> result; std::vector<MiiInfoElement> result;
if ((source_flag & SourceFlag::Default) == SourceFlag::None) { if ((source_flag & SourceFlag::Default) == SourceFlag::None) {

4
src/core/hle/service/mii/mii_manager.h
View file

@ -19,12 +19,12 @@ public:
bool CheckAndResetUpdateCounter(SourceFlag source_flag, u64& current_update_counter); bool CheckAndResetUpdateCounter(SourceFlag source_flag, u64& current_update_counter);
bool IsFullDatabase() const; bool IsFullDatabase() const;
u32 GetCount(SourceFlag source_flag) const; u32 GetCount(SourceFlag source_flag) const;
ResultVal<CharInfo> 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 BuildRandom(Age age, Gender gender, Race race);
CharInfo BuildDefault(std::size_t index); CharInfo BuildDefault(std::size_t index);
CharInfo ConvertV3ToCharInfo(const Ver3StoreData& mii_v3) const; CharInfo ConvertV3ToCharInfo(const Ver3StoreData& mii_v3) const;
bool ValidateV3Info(const Ver3StoreData& mii_v3) const; bool ValidateV3Info(const Ver3StoreData& mii_v3) const;
ResultVal<std::vector<MiiInfoElement>> GetDefault(SourceFlag source_flag); std::vector<MiiInfoElement> GetDefault(SourceFlag source_flag);
Result GetIndex(const CharInfo& info, u32& index); Result GetIndex(const CharInfo& info, u32& index);
// This is nn::mii::detail::Ver::StoreDataRaw::BuildFromStoreData // This is nn::mii::detail::Ver::StoreDataRaw::BuildFromStoreData

41
src/core/hle/service/ns/ns.cpp
View file

@ -392,19 +392,20 @@ void IApplicationManagerInterface::GetApplicationDesiredLanguage(HLERequestConte
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
const auto supported_languages = rp.Pop<u32>(); const auto supported_languages = rp.Pop<u32>();
const auto res = GetApplicationDesiredLanguage(supported_languages); u8 desired_language{};
if (res.Succeeded()) { const auto res = GetApplicationDesiredLanguage(&desired_language, supported_languages);
if (res == ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.Push<u32>(*res); rb.Push<u32>(desired_language);
} else { } else {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res.Code()); rb.Push(res);
} }
} }
ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage( Result IApplicationManagerInterface::GetApplicationDesiredLanguage(u8* out_desired_language,
const u32 supported_languages) { const u32 supported_languages) {
LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages); LOG_DEBUG(Service_NS, "called with supported_languages={:08X}", supported_languages);
// Get language code from settings // Get language code from settings
@ -430,7 +431,8 @@ ResultVal<u8> IApplicationManagerInterface::GetApplicationDesiredLanguage(
for (const auto lang : *priority_list) { for (const auto lang : *priority_list) {
const auto supported_flag = GetSupportedLanguageFlag(lang); const auto supported_flag = GetSupportedLanguageFlag(lang);
if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) { if (supported_languages == 0 || (supported_languages & supported_flag) == supported_flag) {
return static_cast<u8>(lang); *out_desired_language = static_cast<u8>(lang);
return ResultSuccess;
} }
} }
@ -444,19 +446,20 @@ void IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
const auto application_language = rp.Pop<u8>(); const auto application_language = rp.Pop<u8>();
const auto res = ConvertApplicationLanguageToLanguageCode(application_language); u64 language_code{};
if (res.Succeeded()) { const auto res = ConvertApplicationLanguageToLanguageCode(&language_code, application_language);
if (res == ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 4}; IPC::ResponseBuilder rb{ctx, 4};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.Push(*res); rb.Push(language_code);
} else { } else {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res.Code()); rb.Push(res);
} }
} }
ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode( Result IApplicationManagerInterface::ConvertApplicationLanguageToLanguageCode(
u8 application_language) { u64* out_language_code, u8 application_language) {
const auto language_code = const auto language_code =
ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language)); ConvertToLanguageCode(static_cast<ApplicationLanguage>(application_language));
if (language_code == std::nullopt) { if (language_code == std::nullopt) {
@ -464,7 +467,8 @@ ResultVal<u64> IApplicationManagerInterface::ConvertApplicationLanguageToLanguag
return Service::NS::ResultApplicationLanguageNotFound; return Service::NS::ResultApplicationLanguageNotFound;
} }
return static_cast<u64>(*language_code); *out_language_code = static_cast<u64>(*language_code);
return ResultSuccess;
} }
IApplicationVersionInterface::IApplicationVersionInterface(Core::System& system_) IApplicationVersionInterface::IApplicationVersionInterface(Core::System& system_)
@ -618,12 +622,13 @@ void IReadOnlyApplicationControlDataInterface::GetApplicationControlData(HLERequ
static_assert(sizeof(RequestParameters) == 0x10, "RequestParameters has incorrect size."); static_assert(sizeof(RequestParameters) == 0x10, "RequestParameters has incorrect size.");
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
std::vector<u8> nacp_data{};
const auto parameters{rp.PopRaw<RequestParameters>()}; const auto parameters{rp.PopRaw<RequestParameters>()};
const auto nacp_data{system.GetARPManager().GetControlProperty(parameters.application_id)}; const auto result =
const auto result = nacp_data ? ResultSuccess : ResultUnknown; system.GetARPManager().GetControlProperty(&nacp_data, parameters.application_id);
if (nacp_data) { if (result == ResultSuccess) {
ctx.WriteBuffer(nacp_data->data(), nacp_data->size()); ctx.WriteBuffer(nacp_data.data(), nacp_data.size());
} }
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};

5
src/core/hle/service/ns/ns.h
View file

@ -28,8 +28,9 @@ public:
explicit IApplicationManagerInterface(Core::System& system_); explicit IApplicationManagerInterface(Core::System& system_);
~IApplicationManagerInterface() override; ~IApplicationManagerInterface() override;
ResultVal<u8> GetApplicationDesiredLanguage(u32 supported_languages); Result GetApplicationDesiredLanguage(u8* out_desired_language, u32 supported_languages);
ResultVal<u64> ConvertApplicationLanguageToLanguageCode(u8 application_language); Result ConvertApplicationLanguageToLanguageCode(u64* out_language_code,
u8 application_language);
private: private:
void GetApplicationControlData(HLERequestContext& ctx); void GetApplicationControlData(HLERequestContext& ctx);

4
src/core/hle/service/nvnflinger/nvnflinger.cpp
View file

@ -183,7 +183,7 @@ std::optional<u32> Nvnflinger::FindBufferQueueId(u64 display_id, u64 layer_id) {
return layer->GetBinderId(); return layer->GetBinderId();
} }
ResultVal<Kernel::KReadableEvent*> Nvnflinger::FindVsyncEvent(u64 display_id) { Result Nvnflinger::FindVsyncEvent(Kernel::KReadableEvent** out_vsync_event, u64 display_id) {
const auto lock_guard = Lock(); const auto lock_guard = Lock();
auto* const display = FindDisplay(display_id); auto* const display = FindDisplay(display_id);
@ -191,7 +191,7 @@ ResultVal<Kernel::KReadableEvent*> Nvnflinger::FindVsyncEvent(u64 display_id) {
return VI::ResultNotFound; return VI::ResultNotFound;
} }
return display->GetVSyncEvent(); return display->GetVSyncEvent(out_vsync_event);
} }
VI::Display* Nvnflinger::FindDisplay(u64 display_id) { VI::Display* Nvnflinger::FindDisplay(u64 display_id) {

2
src/core/hle/service/nvnflinger/nvnflinger.h
View file

@ -82,7 +82,7 @@ public:
/// ///
/// If an invalid display ID is provided, then VI::ResultNotFound is returned. /// 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. /// If the vsync event has already been retrieved, then VI::ResultPermissionDenied is returned.
[[nodiscard]] ResultVal<Kernel::KReadableEvent*> 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 /// Performs a composition request to the emulated nvidia GPU and triggers the vsync events when
/// finished. /// finished.

9
src/core/hle/service/server_manager.cpp
View file

@ -102,16 +102,17 @@ Result ServerManager::RegisterNamedService(const std::string& service_name,
m_system.ServiceManager().RegisterService(service_name, max_sessions, handler))); m_system.ServiceManager().RegisterService(service_name, max_sessions, handler)));
// Get the registered port. // Get the registered port.
auto port = m_system.ServiceManager().GetServicePort(service_name); Kernel::KPort* port{};
ASSERT(port.Succeeded()); ASSERT(
R_SUCCEEDED(m_system.ServiceManager().GetServicePort(std::addressof(port), service_name)));
// Open a new reference to the server port. // Open a new reference to the server port.
(*port)->GetServerPort().Open(); port->GetServerPort().Open();
// Begin tracking the server port. // Begin tracking the server port.
{ {
std::scoped_lock ll{m_list_mutex}; 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. // Signal the wakeup event.

43
src/core/hle/service/sm/sm.cpp
View file

@ -52,8 +52,7 @@ static Result ValidateServiceName(const std::string& name) {
Result ServiceManager::RegisterService(std::string name, u32 max_sessions, Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
SessionRequestHandlerPtr handler) { SessionRequestHandlerPtr handler) {
R_TRY(ValidateServiceName(name));
CASCADE_CODE(ValidateServiceName(name));
std::scoped_lock lk{lock}; std::scoped_lock lk{lock};
if (registered_services.find(name) != registered_services.end()) { 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) { Result ServiceManager::UnregisterService(const std::string& name) {
CASCADE_CODE(ValidateServiceName(name)); R_TRY(ValidateServiceName(name));
std::scoped_lock lk{lock}; std::scoped_lock lk{lock};
const auto iter = registered_services.find(name); const auto iter = registered_services.find(name);
@ -92,8 +91,8 @@ Result ServiceManager::UnregisterService(const std::string& name) {
return ResultSuccess; return ResultSuccess;
} }
ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name) { Result ServiceManager::GetServicePort(Kernel::KPort** out_port, const std::string& name) {
CASCADE_CODE(ValidateServiceName(name)); R_TRY(ValidateServiceName(name));
std::scoped_lock lk{lock}; std::scoped_lock lk{lock};
auto it = service_ports.find(name); auto it = service_ports.find(name);
@ -102,7 +101,8 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
return Service::SM::ResultNotRegistered; 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) { void SM::GetService(HLERequestContext& ctx) {
auto result = GetServiceImpl(ctx); Kernel::KClientSession* client_session{};
auto result = GetServiceImpl(&client_session, ctx);
if (ctx.GetIsDeferred()) { if (ctx.GetIsDeferred()) {
// Don't overwrite the command buffer. // Don't overwrite the command buffer.
return; return;
} }
if (result.Succeeded()) { if (result == ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles}; IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
rb.Push(result.Code()); rb.Push(result);
rb.PushMoveObjects(result.Unwrap()); rb.PushMoveObjects(client_session);
} else { } else {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result.Code()); rb.Push(result);
} }
} }
void SM::GetServiceTipc(HLERequestContext& ctx) { void SM::GetServiceTipc(HLERequestContext& ctx) {
auto result = GetServiceImpl(ctx); Kernel::KClientSession* client_session{};
auto result = GetServiceImpl(&client_session, ctx);
if (ctx.GetIsDeferred()) { if (ctx.GetIsDeferred()) {
// Don't overwrite the command buffer. // Don't overwrite the command buffer.
return; return;
} }
IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles}; IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
rb.Push(result.Code()); rb.Push(result);
rb.PushMoveObjects(result.Succeeded() ? result.Unwrap() : nullptr); rb.PushMoveObjects(result == ResultSuccess ? client_session : nullptr);
} }
static std::string PopServiceName(IPC::RequestParser& rp) { static std::string PopServiceName(IPC::RequestParser& rp) {
@ -161,7 +163,7 @@ static std::string PopServiceName(IPC::RequestParser& rp) {
return result; return result;
} }
ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) { Result SM::GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx) {
if (!ctx.GetManager()->GetIsInitializedForSm()) { if (!ctx.GetManager()->GetIsInitializedForSm()) {
return Service::SM::ResultInvalidClient; return Service::SM::ResultInvalidClient;
} }
@ -170,18 +172,18 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
std::string name(PopServiceName(rp)); std::string name(PopServiceName(rp));
// Find the named port. // Find the named port.
auto port_result = service_manager.GetServicePort(name); Kernel::KPort* port{};
if (port_result.Code() == Service::SM::ResultInvalidServiceName) { auto port_result = service_manager.GetServicePort(&port, name);
if (port_result == Service::SM::ResultInvalidServiceName) {
LOG_ERROR(Service_SM, "Invalid service name '{}'", name); LOG_ERROR(Service_SM, "Invalid service name '{}'", name);
return Service::SM::ResultInvalidServiceName; return Service::SM::ResultInvalidServiceName;
} }
if (port_result.Failed()) { if (port_result != ResultSuccess) {
LOG_INFO(Service_SM, "Waiting for service {} to become available", name); LOG_INFO(Service_SM, "Waiting for service {} to become available", name);
ctx.SetIsDeferred(); ctx.SetIsDeferred();
return Service::SM::ResultNotRegistered; return Service::SM::ResultNotRegistered;
} }
auto& port = port_result.Unwrap();
// Create a new session. // Create a new session.
Kernel::KClientSession* session{}; Kernel::KClientSession* session{};
@ -192,7 +194,8 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(HLERequestContext& ctx) {
LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId()); LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId());
return session; *out_client_session = session;
return ResultSuccess;
} }
void SM::RegisterService(HLERequestContext& ctx) { void SM::RegisterService(HLERequestContext& ctx) {

4
src/core/hle/service/sm/sm.h
View file

@ -42,7 +42,7 @@ private:
void RegisterService(HLERequestContext& ctx); void RegisterService(HLERequestContext& ctx);
void UnregisterService(HLERequestContext& ctx); void UnregisterService(HLERequestContext& ctx);
ResultVal<Kernel::KClientSession*> GetServiceImpl(HLERequestContext& ctx); Result GetServiceImpl(Kernel::KClientSession** out_client_session, HLERequestContext& ctx);
ServiceManager& service_manager; ServiceManager& service_manager;
Kernel::KernelCore& kernel; Kernel::KernelCore& kernel;
@ -55,7 +55,7 @@ public:
Result RegisterService(std::string name, u32 max_sessions, SessionRequestHandlerPtr handler); Result RegisterService(std::string name, u32 max_sessions, SessionRequestHandlerPtr handler);
Result UnregisterService(const std::string& name); Result UnregisterService(const std::string& name);
ResultVal<Kernel::KPort*> GetServicePort(const std::string& name); Result GetServicePort(Kernel::KPort** out_port, const std::string& name);
template <Common::DerivedFrom<SessionRequestHandler> T> template <Common::DerivedFrom<SessionRequestHandler> T>
std::shared_ptr<T> GetService(const std::string& service_name) const { std::shared_ptr<T> GetService(const std::string& service_name) const {

9
src/core/hle/service/sockets/nsd.cpp
View file

@ -54,7 +54,7 @@ NSD::NSD(Core::System& system_, const char* name) : ServiceFramework{system_, na
RegisterHandlers(functions); RegisterHandlers(functions);
} }
static ResultVal<std::string> ResolveImpl(const std::string& fqdn_in) { static std::string ResolveImpl(const std::string& fqdn_in) {
// The real implementation makes various substitutions. // The real implementation makes various substitutions.
// For now we just return the string as-is, which is good enough when not // For now we just return the string as-is, which is good enough when not
// connecting to real Nintendo servers. // connecting to real Nintendo servers.
@ -64,13 +64,10 @@ static ResultVal<std::string> ResolveImpl(const std::string& fqdn_in) {
static Result ResolveCommon(const std::string& fqdn_in, std::array<char, 0x100>& fqdn_out) { static Result ResolveCommon(const std::string& fqdn_in, std::array<char, 0x100>& fqdn_out) {
const auto res = ResolveImpl(fqdn_in); const auto res = ResolveImpl(fqdn_in);
if (res.Failed()) { if (res.size() >= fqdn_out.size()) {
return res.Code();
}
if (res->size() >= fqdn_out.size()) {
return ResultOverflow; 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; return ResultSuccess;
} }

48
src/core/hle/service/spl/spl_module.cpp
View file

@ -30,10 +30,10 @@ void Module::Interface::GetConfig(HLERequestContext& ctx) {
// This should call svcCallSecureMonitor with the appropriate args. // This should call svcCallSecureMonitor with the appropriate args.
// Since we do not have it implemented yet, we will use this for now. // Since we do not have it implemented yet, we will use this for now.
const auto smc_result = GetConfigImpl(config_item); u64 smc_result{};
const auto result_code = smc_result.Code(); 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, LOG_ERROR(Service_SPL, "called, config_item={}, result_code={}", config_item,
result_code.raw); 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, 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}; IPC::ResponseBuilder rb{ctx, 4};
rb.Push(result_code); rb.Push(result_code);
rb.Push(*smc_result); rb.Push(smc_result);
} }
void Module::Interface::ModularExponentiate(HLERequestContext& ctx) { void Module::Interface::ModularExponentiate(HLERequestContext& ctx) {
@ -99,7 +99,7 @@ void Module::Interface::GetBootReason(HLERequestContext& ctx) {
rb.Push(ResultSecureMonitorNotImplemented); rb.Push(ResultSecureMonitorNotImplemented);
} }
ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const { Result Module::Interface::GetConfigImpl(u64* out_config, ConfigItem config_item) const {
switch (config_item) { switch (config_item) {
case ConfigItem::DisableProgramVerification: case ConfigItem::DisableProgramVerification:
case ConfigItem::DramId: case ConfigItem::DramId:
@ -121,40 +121,50 @@ ResultVal<u64> Module::Interface::GetConfigImpl(ConfigItem config_item) const {
return ResultSecureMonitorNotImplemented; return ResultSecureMonitorNotImplemented;
case ConfigItem::ExosphereApiVersion: case ConfigItem::ExosphereApiVersion:
// Get information about the current exosphere version. // Get information about the current exosphere version.
return (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) | *out_config = (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MAJOR} << 56) |
(u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) | (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MINOR} << 48) |
(u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) | (u64{HLE::ApiVersion::ATMOSPHERE_RELEASE_VERSION_MICRO} << 40) |
(static_cast<u64>(HLE::ApiVersion::GetTargetFirmware())); (static_cast<u64>(HLE::ApiVersion::GetTargetFirmware()));
return ResultSuccess;
case ConfigItem::ExosphereNeedsReboot: case ConfigItem::ExosphereNeedsReboot:
// We are executing, so we aren't in the process of rebooting. // We are executing, so we aren't in the process of rebooting.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
case ConfigItem::ExosphereNeedsShutdown: case ConfigItem::ExosphereNeedsShutdown:
// We are executing, so we aren't in the process of shutting down. // 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: case ConfigItem::ExosphereGitCommitHash:
// Get information about the current exosphere git commit hash. // Get information about the current exosphere git commit hash.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
case ConfigItem::ExosphereHasRcmBugPatch: case ConfigItem::ExosphereHasRcmBugPatch:
// Get information about whether this unit has the RCM bug patched. // Get information about whether this unit has the RCM bug patched.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
case ConfigItem::ExosphereBlankProdInfo: case ConfigItem::ExosphereBlankProdInfo:
// Get whether this unit should simulate a "blanked" PRODINFO. // Get whether this unit should simulate a "blanked" PRODINFO.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
case ConfigItem::ExosphereAllowCalWrites: case ConfigItem::ExosphereAllowCalWrites:
// Get whether this unit should allow writing to the calibration partition. // Get whether this unit should allow writing to the calibration partition.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
case ConfigItem::ExosphereEmummcType: case ConfigItem::ExosphereEmummcType:
// Get what kind of emummc this unit has active. // Get what kind of emummc this unit has active.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
case ConfigItem::ExospherePayloadAddress: case ConfigItem::ExospherePayloadAddress:
// Gets the physical address of the reboot payload buffer, if one exists. // Gets the physical address of the reboot payload buffer, if one exists.
return ResultSecureMonitorNotInitialized; return ResultSecureMonitorNotInitialized;
case ConfigItem::ExosphereLogConfiguration: case ConfigItem::ExosphereLogConfiguration:
// Get the log configuration. // Get the log configuration.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
case ConfigItem::ExosphereForceEnableUsb30: case ConfigItem::ExosphereForceEnableUsb30:
// Get whether usb 3.0 should be force-enabled. // Get whether usb 3.0 should be force-enabled.
return u64{0}; *out_config = u64{0};
return ResultSuccess;
default: default:
return ResultSecureMonitorInvalidArgument; return ResultSecureMonitorInvalidArgument;
} }

2
src/core/hle/service/spl/spl_module.h
View file

@ -35,7 +35,7 @@ public:
std::shared_ptr<Module> module; std::shared_ptr<Module> module;
private: private:
ResultVal<u64> GetConfigImpl(ConfigItem config_item) const; Result GetConfigImpl(u64* out_config, ConfigItem config_item) const;
std::mt19937 rng; std::mt19937 rng;
}; };

86
src/core/hle/service/ssl/ssl.cpp
View file

@ -4,6 +4,7 @@
#include "common/string_util.h" #include "common/string_util.h"
#include "core/core.h" #include "core/core.h"
#include "core/hle/result.h"
#include "core/hle/service/ipc_helpers.h" #include "core/hle/service/ipc_helpers.h"
#include "core/hle/service/server_manager.h" #include "core/hle/service/server_manager.h"
#include "core/hle/service/service.h" #include "core/hle/service/service.h"
@ -141,12 +142,12 @@ private:
bool did_set_host_name = false; bool did_set_host_name = false;
bool did_handshake = false; bool did_handshake = false;
ResultVal<s32> SetSocketDescriptorImpl(s32 fd) { Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
LOG_DEBUG(Service_SSL, "called, fd={}", fd); LOG_DEBUG(Service_SSL, "called, fd={}", fd);
ASSERT(!did_handshake); ASSERT(!did_handshake);
auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u"); auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; }); ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
s32 ret_fd;
// Based on https://switchbrew.org/wiki/SSL_services#SetSocketDescriptor // Based on https://switchbrew.org/wiki/SSL_services#SetSocketDescriptor
if (do_not_close_socket) { if (do_not_close_socket) {
auto res = bsd->DuplicateSocketImpl(fd); auto res = bsd->DuplicateSocketImpl(fd);
@ -156,9 +157,9 @@ private:
} }
fd = *res; fd = *res;
fd_to_close = fd; fd_to_close = fd;
ret_fd = fd; *out_fd = fd;
} else { } else {
ret_fd = -1; *out_fd = -1;
} }
std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(fd); std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(fd);
if (!sock.has_value()) { if (!sock.has_value()) {
@ -167,7 +168,7 @@ private:
} }
socket = std::move(*sock); socket = std::move(*sock);
backend->SetSocket(socket); backend->SetSocket(socket);
return ret_fd; return ResultSuccess;
} }
Result SetHostNameImpl(const std::string& hostname) { Result SetHostNameImpl(const std::string& hostname) {
@ -247,34 +248,36 @@ private:
return ret; return ret;
} }
ResultVal<std::vector<u8>> ReadImpl(size_t size) { Result ReadImpl(std::vector<u8>* out_data, size_t size) {
ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; }); ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
std::vector<u8> res(size); size_t actual_size{};
ResultVal<size_t> actual = backend->Read(res); Result res = backend->Read(&actual_size, *out_data);
if (actual.Failed()) { if (res != ResultSuccess) {
return actual.Code(); return res;
} }
res.resize(*actual); out_data->resize(actual_size);
return res; return res;
} }
ResultVal<size_t> WriteImpl(std::span<const u8> data) { Result WriteImpl(size_t* out_size, std::span<const u8> data) {
ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; }); ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
return backend->Write(data); return backend->Write(out_size, data);
} }
ResultVal<s32> PendingImpl() { Result PendingImpl(s32* out_pending) {
LOG_WARNING(Service_SSL, "(STUBBED) called."); LOG_WARNING(Service_SSL, "(STUBBED) called.");
return 0; *out_pending = 0;
return ResultSuccess;
} }
void SetSocketDescriptor(HLERequestContext& ctx) { void SetSocketDescriptor(HLERequestContext& ctx) {
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
const s32 fd = rp.Pop<s32>(); const s32 in_fd = rp.Pop<s32>();
const ResultVal<s32> res = SetSocketDescriptorImpl(fd); s32 out_fd{-1};
const Result res = SetSocketDescriptorImpl(&out_fd, in_fd);
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(res.Code()); rb.Push(res);
rb.Push<s32>(res.ValueOr(-1)); rb.Push<s32>(out_fd);
} }
void SetHostName(HLERequestContext& ctx) { void SetHostName(HLERequestContext& ctx) {
@ -313,14 +316,15 @@ private:
}; };
static_assert(sizeof(OutputParameters) == 0x8); static_assert(sizeof(OutputParameters) == 0x8);
const Result res = DoHandshakeImpl(); Result res = DoHandshakeImpl();
OutputParameters out{}; OutputParameters out{};
if (res == ResultSuccess) { if (res == ResultSuccess) {
auto certs = backend->GetServerCerts(); std::vector<std::vector<u8>> certs;
if (certs.Succeeded()) { res = backend->GetServerCerts(&certs);
const std::vector<u8> certs_buf = SerializeServerCerts(*certs); if (res == ResultSuccess) {
const std::vector<u8> certs_buf = SerializeServerCerts(certs);
ctx.WriteBuffer(certs_buf); ctx.WriteBuffer(certs_buf);
out.certs_count = static_cast<u32>(certs->size()); out.certs_count = static_cast<u32>(certs.size());
out.certs_size = static_cast<u32>(certs_buf.size()); out.certs_size = static_cast<u32>(certs_buf.size());
} }
} }
@ -330,29 +334,32 @@ private:
} }
void Read(HLERequestContext& ctx) { void Read(HLERequestContext& ctx) {
const ResultVal<std::vector<u8>> res = ReadImpl(ctx.GetWriteBufferSize()); std::vector<u8> output_bytes;
const Result res = ReadImpl(&output_bytes, ctx.GetWriteBufferSize());
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(res.Code()); rb.Push(res);
if (res.Succeeded()) { if (res == ResultSuccess) {
rb.Push(static_cast<u32>(res->size())); rb.Push(static_cast<u32>(output_bytes.size()));
ctx.WriteBuffer(*res); ctx.WriteBuffer(output_bytes);
} else { } else {
rb.Push(static_cast<u32>(0)); rb.Push(static_cast<u32>(0));
} }
} }
void Write(HLERequestContext& ctx) { void Write(HLERequestContext& ctx) {
const ResultVal<size_t> res = WriteImpl(ctx.ReadBuffer()); size_t write_size{0};
const Result res = WriteImpl(&write_size, ctx.ReadBuffer());
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(res.Code()); rb.Push(res);
rb.Push(static_cast<u32>(res.ValueOr(0))); rb.Push(static_cast<u32>(write_size));
} }
void Pending(HLERequestContext& ctx) { void Pending(HLERequestContext& ctx) {
const ResultVal<s32> res = PendingImpl(); s32 pending_size{0};
const Result res = PendingImpl(&pending_size);
IPC::ResponseBuilder rb{ctx, 3}; IPC::ResponseBuilder rb{ctx, 3};
rb.Push(res.Code()); rb.Push(res);
rb.Push<s32>(res.ValueOr(0)); rb.Push<s32>(pending_size);
} }
void SetSessionCacheMode(HLERequestContext& ctx) { void SetSessionCacheMode(HLERequestContext& ctx) {
@ -438,13 +445,14 @@ private:
void CreateConnection(HLERequestContext& ctx) { void CreateConnection(HLERequestContext& ctx) {
LOG_WARNING(Service_SSL, "called"); LOG_WARNING(Service_SSL, "called");
auto backend_res = CreateSSLConnectionBackend(); std::unique_ptr<SSLConnectionBackend> backend;
const Result res = CreateSSLConnectionBackend(&backend);
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(backend_res.Code()); rb.Push(res);
if (backend_res.Succeeded()) { if (res == ResultSuccess) {
rb.PushIpcInterface<ISslConnection>(system, ssl_version, shared_data, rb.PushIpcInterface<ISslConnection>(system, ssl_version, shared_data,
std::move(*backend_res)); std::move(backend));
} }
} }

8
src/core/hle/service/ssl/ssl_backend.h
View file

@ -35,11 +35,11 @@ public:
virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0; virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0;
virtual Result SetHostName(const std::string& hostname) = 0; virtual Result SetHostName(const std::string& hostname) = 0;
virtual Result DoHandshake() = 0; virtual Result DoHandshake() = 0;
virtual ResultVal<size_t> Read(std::span<u8> data) = 0; virtual Result Read(size_t* out_size, std::span<u8> data) = 0;
virtual ResultVal<size_t> Write(std::span<const u8> data) = 0; virtual Result Write(size_t* out_size, std::span<const u8> data) = 0;
virtual ResultVal<std::vector<std::vector<u8>>> GetServerCerts() = 0; virtual Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) = 0;
}; };
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend(); Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend);
} // namespace Service::SSL } // namespace Service::SSL

2
src/core/hle/service/ssl/ssl_backend_none.cpp
View file

@ -7,7 +7,7 @@
namespace Service::SSL { namespace Service::SSL {
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
LOG_ERROR(Service_SSL, LOG_ERROR(Service_SSL,
"Can't create SSL connection because no SSL backend is available on this platform"); "Can't create SSL connection because no SSL backend is available on this platform");
return ResultInternalError; return ResultInternalError;

45
src/core/hle/service/ssl/ssl_backend_openssl.cpp
View file

@ -105,31 +105,30 @@ public:
return ResultInternalError; return ResultInternalError;
} }
} }
return HandleReturn("SSL_do_handshake", 0, ret).Code(); return HandleReturn("SSL_do_handshake", 0, ret);
} }
ResultVal<size_t> Read(std::span<u8> data) override { Result Read(size_t* out_size, std::span<u8> data) override {
size_t actual; const int ret = SSL_read_ex(ssl, data.data(), data.size(), out_size);
const int ret = SSL_read_ex(ssl, data.data(), data.size(), &actual); return HandleReturn("SSL_read_ex", out_size, ret);
return HandleReturn("SSL_read_ex", actual, ret);
} }
ResultVal<size_t> Write(std::span<const u8> data) override { Result Write(size_t* out_size, std::span<const u8> data) override {
size_t actual; const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size);
const int ret = SSL_write_ex(ssl, data.data(), data.size(), &actual); return HandleReturn("SSL_write_ex", out_size, ret);
return HandleReturn("SSL_write_ex", actual, ret);
} }
ResultVal<size_t> 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); const int ssl_err = SSL_get_error(ssl, ret);
CheckOpenSSLErrors(); CheckOpenSSLErrors();
switch (ssl_err) { switch (ssl_err) {
case SSL_ERROR_NONE: case SSL_ERROR_NONE:
return actual; return ResultSuccess;
case SSL_ERROR_ZERO_RETURN: case SSL_ERROR_ZERO_RETURN:
LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_ZERO_RETURN", what); LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_ZERO_RETURN", what);
// DoHandshake special-cases this, but for Read and Write: // DoHandshake special-cases this, but for Read and Write:
return size_t(0); *actual = 0;
return ResultSuccess;
case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_READ:
LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_WANT_READ", what); LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_WANT_READ", what);
return ResultWouldBlock; return ResultWouldBlock;
@ -139,20 +138,20 @@ public:
default: default:
if (ssl_err == SSL_ERROR_SYSCALL && got_read_eof) { if (ssl_err == SSL_ERROR_SYSCALL && got_read_eof) {
LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_SYSCALL because server hung up", what); 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); LOG_ERROR(Service_SSL, "{} => other SSL_get_error return value {}", what, ssl_err);
return ResultInternalError; return ResultInternalError;
} }
} }
ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override { Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) override {
STACK_OF(X509)* chain = SSL_get_peer_cert_chain(ssl); STACK_OF(X509)* chain = SSL_get_peer_cert_chain(ssl);
if (!chain) { if (!chain) {
LOG_ERROR(Service_SSL, "SSL_get_peer_cert_chain returned nullptr"); LOG_ERROR(Service_SSL, "SSL_get_peer_cert_chain returned nullptr");
return ResultInternalError; return ResultInternalError;
} }
std::vector<std::vector<u8>> ret;
int count = sk_X509_num(chain); int count = sk_X509_num(chain);
ASSERT(count >= 0); ASSERT(count >= 0);
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
@ -161,10 +160,10 @@ public:
unsigned char* buf = nullptr; unsigned char* buf = nullptr;
int len = i2d_X509(x509, &buf); int len = i2d_X509(x509, &buf);
ASSERT_OR_EXECUTE(len >= 0 && buf, { continue; }); ASSERT_OR_EXECUTE(len >= 0 && buf, { continue; });
ret.emplace_back(buf, buf + len); out_certs->emplace_back(buf, buf + len);
OPENSSL_free(buf); OPENSSL_free(buf);
} }
return ret; return ResultSuccess;
} }
~SSLConnectionBackendOpenSSL() { ~SSLConnectionBackendOpenSSL() {
@ -253,13 +252,13 @@ public:
std::shared_ptr<Network::SocketBase> socket; std::shared_ptr<Network::SocketBase> socket;
}; };
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
auto conn = std::make_unique<SSLConnectionBackendOpenSSL>(); auto conn = std::make_unique<SSLConnectionBackendOpenSSL>();
const Result res = conn->Init();
if (res.IsFailure()) { R_TRY(conn->Init());
return res;
} *out_backend = std::move(conn);
return conn; return ResultSuccess;
} }
namespace { namespace {

62
src/core/hle/service/ssl/ssl_backend_schannel.cpp
View file

@ -299,21 +299,22 @@ public:
return ResultSuccess; return ResultSuccess;
} }
ResultVal<size_t> Read(std::span<u8> data) override { Result Read(size_t* out_size, std::span<u8> data) override {
*out_size = 0;
if (handshake_state != HandshakeState::Connected) { if (handshake_state != HandshakeState::Connected) {
LOG_ERROR(Service_SSL, "Called Read but we did not successfully handshake"); LOG_ERROR(Service_SSL, "Called Read but we did not successfully handshake");
return ResultInternalError; return ResultInternalError;
} }
if (data.size() == 0 || got_read_eof) { if (data.size() == 0 || got_read_eof) {
return size_t(0); return ResultSuccess;
} }
while (1) { while (1) {
if (!cleartext_read_buf.empty()) { if (!cleartext_read_buf.empty()) {
const size_t read_size = std::min(cleartext_read_buf.size(), data.size()); *out_size = std::min(cleartext_read_buf.size(), data.size());
std::memcpy(data.data(), cleartext_read_buf.data(), read_size); std::memcpy(data.data(), cleartext_read_buf.data(), *out_size);
cleartext_read_buf.erase(cleartext_read_buf.begin(), cleartext_read_buf.erase(cleartext_read_buf.begin(),
cleartext_read_buf.begin() + read_size); cleartext_read_buf.begin() + *out_size);
return read_size; return ResultSuccess;
} }
if (!ciphertext_read_buf.empty()) { if (!ciphertext_read_buf.empty()) {
SecBuffer empty{ SecBuffer empty{
@ -366,7 +367,8 @@ public:
case SEC_I_CONTEXT_EXPIRED: case SEC_I_CONTEXT_EXPIRED:
// Server hung up by sending close_notify. // Server hung up by sending close_notify.
got_read_eof = true; got_read_eof = true;
return size_t(0); *out_size = 0;
return ResultSuccess;
default: default:
LOG_ERROR(Service_SSL, "DecryptMessage failed: {}", LOG_ERROR(Service_SSL, "DecryptMessage failed: {}",
Common::NativeErrorToString(ret)); Common::NativeErrorToString(ret));
@ -379,18 +381,21 @@ public:
} }
if (ciphertext_read_buf.empty()) { if (ciphertext_read_buf.empty()) {
got_read_eof = true; got_read_eof = true;
return size_t(0); *out_size = 0;
return ResultSuccess;
} }
} }
} }
ResultVal<size_t> Write(std::span<const u8> data) override { Result Write(size_t* out_size, std::span<const u8> data) override {
*out_size = 0;
if (handshake_state != HandshakeState::Connected) { if (handshake_state != HandshakeState::Connected) {
LOG_ERROR(Service_SSL, "Called Write but we did not successfully handshake"); LOG_ERROR(Service_SSL, "Called Write but we did not successfully handshake");
return ResultInternalError; return ResultInternalError;
} }
if (data.size() == 0) { if (data.size() == 0) {
return size_t(0); return ResultSuccess;
} }
data = data.subspan(0, std::min<size_t>(data.size(), stream_sizes.cbMaximumMessage)); data = data.subspan(0, std::min<size_t>(data.size(), stream_sizes.cbMaximumMessage));
if (!cleartext_write_buf.empty()) { if (!cleartext_write_buf.empty()) {
@ -402,7 +407,7 @@ public:
LOG_ERROR(Service_SSL, "Called Write but buffer does not match previous buffer"); LOG_ERROR(Service_SSL, "Called Write but buffer does not match previous buffer");
return ResultInternalError; return ResultInternalError;
} }
return WriteAlreadyEncryptedData(); return WriteAlreadyEncryptedData(out_size);
} else { } else {
cleartext_write_buf.assign(data.begin(), data.end()); cleartext_write_buf.assign(data.begin(), data.end());
} }
@ -448,21 +453,21 @@ public:
tmp_data_buf.end()); tmp_data_buf.end());
ciphertext_write_buf.insert(ciphertext_write_buf.end(), trailer_buf.begin(), ciphertext_write_buf.insert(ciphertext_write_buf.end(), trailer_buf.begin(),
trailer_buf.end()); trailer_buf.end());
return WriteAlreadyEncryptedData(); return WriteAlreadyEncryptedData(out_size);
} }
ResultVal<size_t> WriteAlreadyEncryptedData() { Result WriteAlreadyEncryptedData(size_t* out_size) {
const Result r = FlushCiphertextWriteBuf(); const Result r = FlushCiphertextWriteBuf();
if (r != ResultSuccess) { if (r != ResultSuccess) {
return r; return r;
} }
// write buf is empty // write buf is empty
const size_t cleartext_bytes_written = cleartext_write_buf.size(); *out_size = cleartext_write_buf.size();
cleartext_write_buf.clear(); cleartext_write_buf.clear();
return cleartext_bytes_written; return ResultSuccess;
} }
ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override { Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) override {
PCCERT_CONTEXT returned_cert = nullptr; PCCERT_CONTEXT returned_cert = nullptr;
const SECURITY_STATUS ret = const SECURITY_STATUS ret =
QueryContextAttributes(&ctxt, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &returned_cert); QueryContextAttributes(&ctxt, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &returned_cert);
@ -473,16 +478,15 @@ public:
return ResultInternalError; return ResultInternalError;
} }
PCCERT_CONTEXT some_cert = nullptr; PCCERT_CONTEXT some_cert = nullptr;
std::vector<std::vector<u8>> certs;
while ((some_cert = CertEnumCertificatesInStore(returned_cert->hCertStore, some_cert))) { while ((some_cert = CertEnumCertificatesInStore(returned_cert->hCertStore, some_cert))) {
certs.emplace_back(static_cast<u8*>(some_cert->pbCertEncoded), out_certs->emplace_back(static_cast<u8*>(some_cert->pbCertEncoded),
static_cast<u8*>(some_cert->pbCertEncoded) + static_cast<u8*>(some_cert->pbCertEncoded) +
some_cert->cbCertEncoded); some_cert->cbCertEncoded);
} }
std::reverse(certs.begin(), std::reverse(out_certs->begin(),
certs.end()); // Windows returns certs in reverse order from what we want out_certs->end()); // Windows returns certs in reverse order from what we want
CertFreeCertificateContext(returned_cert); CertFreeCertificateContext(returned_cert);
return certs; return ResultSuccess;
} }
~SSLConnectionBackendSchannel() { ~SSLConnectionBackendSchannel() {
@ -532,13 +536,13 @@ public:
size_t read_buf_fill_size = 0; size_t read_buf_fill_size = 0;
}; };
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
auto conn = std::make_unique<SSLConnectionBackendSchannel>(); auto conn = std::make_unique<SSLConnectionBackendSchannel>();
const Result res = conn->Init();
if (res.IsFailure()) { R_TRY(conn->Init());
return res;
} *out_backend = std::move(conn);
return conn; return ResultSuccess;
} }
} // namespace Service::SSL } // namespace Service::SSL

39
src/core/hle/service/ssl/ssl_backend_securetransport.cpp
View file

@ -103,24 +103,20 @@ public:
return HandleReturn("SSLHandshake", 0, status).Code(); return HandleReturn("SSLHandshake", 0, status).Code();
} }
ResultVal<size_t> Read(std::span<u8> data) override { Result Read(size_t* out_size, std::span<u8> data) override {
size_t actual; OSStatus status = SSLRead(context, data.data(), data.size(), out_size);
OSStatus status = SSLRead(context, data.data(), data.size(), &actual); return HandleReturn("SSLRead", out_size, status);
;
return HandleReturn("SSLRead", actual, status);
} }
ResultVal<size_t> Write(std::span<const u8> data) override { Result Write(size_t* out_size, std::span<const u8> data) override {
size_t actual; OSStatus status = SSLWrite(context, data.data(), data.size(), out_size);
OSStatus status = SSLWrite(context, data.data(), data.size(), &actual); return HandleReturn("SSLWrite", out_size, status);
;
return HandleReturn("SSLWrite", actual, status);
} }
ResultVal<size_t> HandleReturn(const char* what, size_t actual, OSStatus status) { Result HandleReturn(const char* what, size_t* actual, OSStatus status) {
switch (status) { switch (status) {
case 0: case 0:
return actual; return ResultSuccess;
case errSSLWouldBlock: case errSSLWouldBlock:
return ResultWouldBlock; return ResultWouldBlock;
default: { default: {
@ -136,22 +132,21 @@ public:
} }
} }
ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override { Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) override {
CFReleaser<SecTrustRef> trust; CFReleaser<SecTrustRef> trust;
OSStatus status = SSLCopyPeerTrust(context, &trust.ptr); OSStatus status = SSLCopyPeerTrust(context, &trust.ptr);
if (status) { if (status) {
LOG_ERROR(Service_SSL, "SSLCopyPeerTrust failed: {}", OSStatusToString(status)); LOG_ERROR(Service_SSL, "SSLCopyPeerTrust failed: {}", OSStatusToString(status));
return ResultInternalError; return ResultInternalError;
} }
std::vector<std::vector<u8>> ret;
for (CFIndex i = 0, count = SecTrustGetCertificateCount(trust); i < count; i++) { for (CFIndex i = 0, count = SecTrustGetCertificateCount(trust); i < count; i++) {
SecCertificateRef cert = SecTrustGetCertificateAtIndex(trust, i); SecCertificateRef cert = SecTrustGetCertificateAtIndex(trust, i);
CFReleaser<CFDataRef> data(SecCertificateCopyData(cert)); CFReleaser<CFDataRef> data(SecCertificateCopyData(cert));
ASSERT_OR_EXECUTE(data, { return ResultInternalError; }); ASSERT_OR_EXECUTE(data, { return ResultInternalError; });
const u8* ptr = CFDataGetBytePtr(data); 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) { static OSStatus ReadCallback(SSLConnectionRef connection, void* data, size_t* dataLength) {
@ -210,13 +205,13 @@ private:
std::shared_ptr<Network::SocketBase> socket; std::shared_ptr<Network::SocketBase> socket;
}; };
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {
auto conn = std::make_unique<SSLConnectionBackendSecureTransport>(); auto conn = std::make_unique<SSLConnectionBackendSecureTransport>();
const Result res = conn->Init();
if (res.IsFailure()) { R_TRY(conn->Init());
return res;
} *out_backend = std::move(conn);
return conn; return ResultSuccess;
} }
} // namespace Service::SSL } // namespace Service::SSL

5
src/core/hle/service/vi/display/vi_display.cpp
View file

@ -58,14 +58,15 @@ const Layer& Display::GetLayer(std::size_t index) const {
return *layers.at(index); return *layers.at(index);
} }
ResultVal<Kernel::KReadableEvent*> Display::GetVSyncEvent() { Result Display::GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event) {
if (got_vsync_event) { if (got_vsync_event) {
return ResultPermissionDenied; return ResultPermissionDenied;
} }
got_vsync_event = true; got_vsync_event = true;
return GetVSyncEventUnchecked(); *out_vsync_event = GetVSyncEventUnchecked();
return ResultSuccess;
} }
Kernel::KReadableEvent* Display::GetVSyncEventUnchecked() { Kernel::KReadableEvent* Display::GetVSyncEventUnchecked() {

2
src/core/hle/service/vi/display/vi_display.h
View file

@ -85,7 +85,7 @@ public:
* @returns The internal Vsync event if it has not yet been retrieved, * @returns The internal Vsync event if it has not yet been retrieved,
* VI::ResultPermissionDenied otherwise. * VI::ResultPermissionDenied otherwise.
*/ */
[[nodiscard]] ResultVal<Kernel::KReadableEvent*> GetVSyncEvent(); [[nodiscard]] Result GetVSyncEvent(Kernel::KReadableEvent** out_vsync_event);
/// Gets the internal vsync event. /// Gets the internal vsync event.
Kernel::KReadableEvent* GetVSyncEventUnchecked(); Kernel::KReadableEvent* GetVSyncEventUnchecked();

35
src/core/hle/service/vi/vi.cpp
View file

@ -683,9 +683,9 @@ private:
LOG_DEBUG(Service_VI, "called. display_id={}", display_id); LOG_DEBUG(Service_VI, "called. display_id={}", display_id);
const auto vsync_event = nv_flinger.FindVsyncEvent(display_id); Kernel::KReadableEvent* vsync_event{};
if (vsync_event.Failed()) { const auto result = nv_flinger.FindVsyncEvent(&vsync_event, display_id);
const auto result = vsync_event.Code(); if (result != ResultSuccess) {
if (result == ResultNotFound) { if (result == ResultNotFound) {
LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id); LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
} }
@ -697,7 +697,7 @@ private:
IPC::ResponseBuilder rb{ctx, 2, 1}; IPC::ResponseBuilder rb{ctx, 2, 1};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.PushCopyObjects(*vsync_event); rb.PushCopyObjects(vsync_event);
} }
void ConvertScalingMode(HLERequestContext& ctx) { void ConvertScalingMode(HLERequestContext& ctx) {
@ -705,15 +705,16 @@ private:
const auto mode = rp.PopEnum<NintendoScaleMode>(); const auto mode = rp.PopEnum<NintendoScaleMode>();
LOG_DEBUG(Service_VI, "called mode={}", mode); 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}; IPC::ResponseBuilder rb{ctx, 4};
rb.Push(ResultSuccess); rb.Push(ResultSuccess);
rb.PushEnum(*converted_mode); rb.PushEnum(converted_mode);
} else { } else {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(converted_mode.Code()); rb.Push(result);
} }
} }
@ -760,18 +761,24 @@ private:
rb.Push(alignment); rb.Push(alignment);
} }
static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) { static Result ConvertScalingModeImpl(ConvertedScaleMode* out_scaling_mode,
NintendoScaleMode mode) {
switch (mode) { switch (mode) {
case NintendoScaleMode::None: case NintendoScaleMode::None:
return ConvertedScaleMode::None; *out_scaling_mode = ConvertedScaleMode::None;
return ResultSuccess;
case NintendoScaleMode::Freeze: case NintendoScaleMode::Freeze:
return ConvertedScaleMode::Freeze; *out_scaling_mode = ConvertedScaleMode::Freeze;
return ResultSuccess;
case NintendoScaleMode::ScaleToWindow: case NintendoScaleMode::ScaleToWindow:
return ConvertedScaleMode::ScaleToWindow; *out_scaling_mode = ConvertedScaleMode::ScaleToWindow;
return ResultSuccess;
case NintendoScaleMode::ScaleAndCrop: case NintendoScaleMode::ScaleAndCrop:
return ConvertedScaleMode::ScaleAndCrop; *out_scaling_mode = ConvertedScaleMode::ScaleAndCrop;
return ResultSuccess;
case NintendoScaleMode::PreserveAspectRatio: case NintendoScaleMode::PreserveAspectRatio:
return ConvertedScaleMode::PreserveAspectRatio; *out_scaling_mode = ConvertedScaleMode::PreserveAspectRatio;
return ResultSuccess;
default: default:
LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode); LOG_ERROR(Service_VI, "Invalid scaling mode specified, mode={}", mode);
return ResultOperationFailed; return ResultOperationFailed;