Trigger build

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/core/hle/service/acc/profile_manager.h

@@ -23,6 +23,12 @@ constexpr std::size_t profile_username_size{32};
 using ProfileUsername = std::array<u8, profile_username_size>;
 using UserIDArray = std::array<Common::UUID, MAX_USERS>;
 
+// This is nn::account::Uid
+struct Uid {
+    std::array<u8, 0x10> unk0;
+};
+static_assert(sizeof(Uid) == 0x10);
+
 /// Contains extra data related to a user.
 /// TODO: RE this structure
 struct UserData {

src/core/hle/service/filesystem/fsp/fsp_srv.cpp

@@ -154,6 +154,9 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {720, nullptr, "AbandonAccessFailure"},
         {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
         {810, nullptr, "RegisterProgramIndexMapInfo"},
+        {820, nullptr, "GetContentStorageInfoIndex"},
+        {830, nullptr, "EncryptStreamPlaySaveData"},
+        {831, nullptr, "DecryptStreamPlaySaveData"},
         {1000, nullptr, "SetBisRootForHost"},
         {1001, nullptr, "SetSaveDataSize"},
         {1002, nullptr, "SetSaveDataRootPath"},

src/core/hle/service/ipc_helpers.h

@@ -22,6 +22,7 @@
 
 namespace IPC {
 
+constexpr Result ResultNotSupported{ErrorModule::HIPC, 1};
 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};
 
 struct ResponseBuilder {

src/core/hle/service/ngc/ngc.cpp

@@ -6,10 +6,16 @@
 
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/hle/kernel/k_client_session.h"
+#include "core/hle/result.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ngc/ngc.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
+#include "frontend_common/firmware_manager.h"
 
 namespace Service::NGC {
 
@@ -166,12 +172,123 @@ public:
     }
 };
 
+struct SaveDataHandle {
+    u64 unk0;
+};
+static_assert(sizeof(SaveDataHandle) == 0x08);
+
+class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
+public:
+    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {450, nullptr, "InitializeForSaveData"},
+            {451, nullptr, "FinalizeForSaveData"},
+            {452, D<&IUserShimScopedObject::OpenSaveData>, "OpenSaveData"},
+            {453, nullptr, "CloseSaveData"},
+            {454, D<&IUserShimScopedObject::ReadSaveSlot>, "ReadSaveSlot"},
+            {455, D<&IUserShimScopedObject::WriteSaveSlot>, "WriteSaveSlot"},
+            {456, nullptr, "FlushSaveSlot"},
+            {457, nullptr, "CommitSaveData"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+    Result OpenSaveData(Account::Uid unk0, Out<SaveDataHandle> unk1) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result ReadSaveSlot(s32 offset, SaveDataHandle handle, OutBuffer<BufferAttr_HipcAutoSelect> out_data, Out<u32> out_size) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result WriteSaveSlot(s32 offset, SaveDataHandle handle, InBuffer<BufferAttr_HipcAutoSelect> out_data) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        // to implement
+        R_SUCCEED();
+    }
+};
+
+class IUserService final : public ServiceFramework<IUserService> {
+public:
+    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&IUserService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+    Result Cmd0(u32 unk0, OutInterface<IUserShimScopedObject> out_interface) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        *out_interface = std::make_shared<IUserShimScopedObject>(system);
+        R_SUCCEED();
+    }
+};
+
+class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
+public:
+    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {106, nullptr, "Cmd106"},
+            {107, nullptr, "Cmd107"},
+            {108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
+            {207, nullptr, "Cmd207"},
+            {208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
+            {209, nullptr, "Cmd209"},
+            {210, nullptr, "Cmd210"},
+            {211, nullptr, "Cmd211"},
+            {212, nullptr, "Cmd212"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+
+    Result Cmd108() {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+
+    Result Cmd208(Out<std::array<u8, 0x20>> unk0) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        R_THROW(IPC::ResultNotSupported);
+    }
+};
+
+class ISystemService final : public ServiceFramework<ISystemService> {
+public:
+    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&ISystemService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+    }
+    Result Cmd0(OutInterface<ISystemShimScopedObject> out_interface) {
+        LOG_WARNING(Service_NGC, "stubbed");
+        *out_interface = std::make_shared<ISystemShimScopedObject>(system);
+        R_SUCCEED();
+    }
+};
+
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
     server_manager->RegisterNamedService("ngct:u", std::make_shared<IService>(system), 4);
     server_manager->RegisterNamedService("ngct:s", std::make_shared<IServiceWithManagementApi>(system), 4);
     server_manager->RegisterNamedService("ngc:u", std::make_shared<NgcServiceImpl>(system), 4);
+
+    // +23.0.0
+    if (FirmwareManager::GetFirmwareVersion(system).first.major >= 23) {
+        server_manager->RegisterNamedService("stpl:u", std::make_shared<IUserService>(system), 4);
+        server_manager->RegisterNamedService("stpl:sys", std::make_shared<ISystemService>(system), 4);
+    }
+
     ServerManager::RunServer(std::move(server_manager));
 }