OS: get System::AddGlueRegistrationForProcess added

Author: N3xoX1

src/nxemu-loader/system_loader.cpp

@@ -138,7 +138,7 @@ bool Systemloader::Impl::LoadNRO(const char* nroFile)
     m_TitleID = Nacp->GetTitleId();
     m_fsController.RegisterProcess(processID, m_TitleID, std::make_unique<FileSys::RomFSFactory>(nullptr, false, *m_contentProvider, m_fsController));
     g_settings->SetString(NXCoreSetting::GameName, Nacp->GetApplicationName().c_str());
-    operatingSystem.StartApplicationProcess(baseAddress, metaData.GetMainThreadPriority(), metaData.GetMainThreadStackSize());
+    operatingSystem.StartApplicationProcess(metaData.GetMainThreadPriority(), metaData.GetMainThreadStackSize(), 0, StorageId::None, StorageId::None, nullptr, 0);
     return true;
 }
 

src/nxemu-module-spec/operating_system.h

@@ -18,6 +18,15 @@ enum class PoolPartition : uint32_t
     SystemNonSecure = 3,
 };
 
+enum class StorageId : uint8_t {
+    None = 0,
+    Host = 1,
+    GameCard = 2,
+    NandSystem = 3,
+    NandUser = 4,
+    SdCard = 5,
+};
+
 __interface IProgramMetadata
 {
     bool Is64BitProgram() const = 0;
@@ -58,7 +67,7 @@ __interface IOperatingSystem
 {
     bool Initialize(void) = 0;
     bool CreateApplicationProcess(uint64_t codeSize, const IProgramMetadata & metaData, uint64_t & baseAddress, uint64_t & processID, bool is_hbl) = 0;
-    void StartApplicationProcess(uint64_t baseAddress, int32_t priority, int64_t stackSize) = 0;
+    void StartApplicationProcess(int32_t priority, int64_t stackSize, uint32_t version, StorageId baseGameStorageId, StorageId updateStorageId, uint8_t * nacpData, uint32_t nacpDataLen) = 0;
     bool LoadModule(const IModuleInfo & module, uint64_t baseAddress) = 0;
     IDeviceMemory & DeviceMemory(void) = 0;
     void KeyboardKeyPress(int modifier, int keyIndex, int keyCode) = 0;

src/nxemu-os/core/core.cpp

@@ -20,6 +20,7 @@
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/apm/apm_controller.h"
 #include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/glue/glue_manager.h"
 #include "core/hle/service/services.h"
 #include "core/perf_stats.h"
 #include "yuzu_hid_core/hid_core.h"
@@ -121,6 +122,7 @@ struct System::Impl {
 
         kernel.Initialize();
         cpu_manager.Initialize();
+        arp_manager.ResetAll();
 
         service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
         services =
@@ -186,6 +188,9 @@ struct System::Impl {
     /// APM (Performance) services
     Service::APM::Controller apm_controller{core_timing};
 
+    /// Service State
+    Service::Glue::ARPManager arp_manager;
+
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
 
@@ -353,6 +358,23 @@ u64 System::GetApplicationProcessProgramID() const {
     return impl->kernel.ApplicationProcess()->GetProgramId();
 }
 
+void System::AddGlueRegistrationForProcess(Kernel::KProcess & process, uint32_t version, StorageId baseGameStorageId, StorageId updateStorageId, uint8_t * nacpData, uint32_t nacpDataLen) {
+    std::vector<u8> nacp_data;
+    if (nacpDataLen > 0)
+    {
+        nacp_data.resize(nacpDataLen);
+        memcpy(nacp_data.data(), nacpData, nacpDataLen);
+    }
+
+    Service::Glue::ApplicationLaunchProperty launch{};
+    launch.title_id = process.GetProgramId();
+    launch.version = version;
+    launch.base_game_storage_id = baseGameStorageId;
+    launch.update_storage_id = updateStorageId;
+
+    impl->arp_manager.Register(launch.title_id, launch, std::move(nacp_data));
+}
+
 void System::SetFrontendAppletSet(Service::AM::Frontend::FrontendAppletSet&& set) {
     impl->frontend_applets.SetFrontendAppletSet(std::move(set));
 }
@@ -373,6 +395,14 @@ IFileSystemController & System::GetFileSystemController() {
     return impl->fs_controller;
 }
 
+Service::Glue::ARPManager& System::GetARPManager() {
+    return impl->arp_manager;
+}
+
+const Service::Glue::ARPManager& System::GetARPManager() const {
+    return impl->arp_manager;
+}
+
 Service::APM::Controller& System::GetAPMController() {
     return impl->apm_controller;
 }

src/nxemu-os/core/core.h

@@ -14,6 +14,8 @@
 
 #include "yuzu_common/common_types.h"
 
+enum class StorageId : uint8_t;
+
 __interface ISwitchSystem;
 __interface IVideo;
 __interface ISystemloader;
@@ -321,6 +323,8 @@ class System {
     [[nodiscard]] Service::SM::ServiceManager& ServiceManager();
     [[nodiscard]] const Service::SM::ServiceManager& ServiceManager() const;
 
+    void AddGlueRegistrationForProcess(Kernel::KProcess& process, uint32_t version, StorageId baseGameStorageId, StorageId updateStorageId, uint8_t* nacpData, uint32_t nacpDataLen);
+
     void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
                            const std::array<u8, 0x20>& build_id, u64 main_region_begin,
                            u64 main_region_size);

src/nxemu-os/core/hle/service/acc/acc.cpp

@@ -9,6 +9,7 @@
 #include "yuzu_common/fs/path_util.h"
 #include "yuzu_common/logging/log.h"
 #include "yuzu_common/polyfill_ranges.h"
+#include "yuzu_common/stb.h"
 #include "yuzu_common/string_util.h"
 #include "yuzu_common/swap.h"
 #include "core/constants.h"
@@ -42,6 +43,31 @@ static void JPGToMemory(void* context, void* data, int len) {
     jpg_image->insert(jpg_image->end(), jpg, jpg + len);
 }
 
+static void SanitizeJPEGImageSize(std::vector<u8>& image) {
+    constexpr std::size_t max_jpeg_image_size = 0x20000;
+    constexpr int profile_dimensions = 256;
+    int original_width, original_height, color_channels;
+
+    const auto plain_image =
+        stbi_load_from_memory(image.data(), static_cast<int>(image.size()), &original_width,
+                              &original_height, &color_channels, STBI_rgb);
+
+    // Resize image to match 256*256
+    if (original_width != profile_dimensions || original_height != profile_dimensions) {
+        // Use vector instead of array to avoid overflowing the stack
+        std::vector<u8> out_image(profile_dimensions * profile_dimensions * STBI_rgb);
+        stbir_resize_uint8_srgb(plain_image, original_width, original_height, 0, out_image.data(),
+                                profile_dimensions, profile_dimensions, 0, STBI_rgb, 0,
+                                STBIR_FILTER_BOX);
+        image.clear();
+        if (!stbi_write_jpg_to_func(JPGToMemory, &image, profile_dimensions, profile_dimensions,
+                                    STBI_rgb, out_image.data(), 0)) {
+            LOG_ERROR(Service_ACC, "Failed to resize the user provided image.");
+        }
+    }
+
+    image.resize(std::min(image.size(), max_jpeg_image_size));
+}
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
 public:
@@ -286,6 +312,8 @@ class IProfileCommon : public ServiceFramework<IProfileCommon> {
         static const FunctionInfo functions[] = {
             {0, &IProfileCommon::Get, "Get"},
             {1, &IProfileCommon::GetBase, "GetBase"},
+            {10, &IProfileCommon::GetImageSize, "GetImageSize"},
+            {11, &IProfileCommon::LoadImage, "LoadImage"},
         };
 
         RegisterHandlers(functions);
@@ -332,6 +360,58 @@ class IProfileCommon : public ServiceFramework<IProfileCommon> {
         }
     }
 
+    void LoadImage(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_ACC, "called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+
+        const Common::FS::IOFile image(GetImagePath(user_id), Common::FS::FileAccessMode::Read,
+                                       Common::FS::FileType::BinaryFile);
+        if (!image.IsOpen()) {
+            LOG_WARNING(Service_ACC,
+                        "Failed to load user provided image! Falling back to built-in backup...");
+            ctx.WriteBuffer(Core::Constants::ACCOUNT_BACKUP_JPEG);
+            rb.Push(static_cast<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+            return;
+        }
+
+        std::vector<u8> buffer(image.GetSize());
+
+        if (image.Read(buffer) != buffer.size()) {
+            LOG_ERROR(Service_ACC, "Failed to read all the bytes in the user provided image.");
+        }
+
+        SanitizeJPEGImageSize(buffer);
+
+        ctx.WriteBuffer(buffer);
+        rb.Push(static_cast<u32>(buffer.size()));
+    }
+
+    void GetImageSize(HLERequestContext& ctx) {
+        LOG_DEBUG(Service_ACC, "called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+
+        const Common::FS::IOFile image(GetImagePath(user_id), Common::FS::FileAccessMode::Read,
+                                       Common::FS::FileType::BinaryFile);
+
+        if (!image.IsOpen()) {
+            LOG_WARNING(Service_ACC,
+                        "Failed to load user provided image! Falling back to built-in backup...");
+            rb.Push(static_cast<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+            return;
+        }
+
+        std::vector<u8> buffer(image.GetSize());
+
+        if (image.Read(buffer) != buffer.size()) {
+            LOG_ERROR(Service_ACC, "Failed to read all the bytes in the user provided image.");
+        }
+
+        SanitizeJPEGImageSize(buffer);
+        rb.Push(static_cast<u32>(buffer.size()));
+    }
 
     void Store(HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
@@ -708,13 +788,74 @@ void Module::Interface::IsUserRegistrationRequestPermitted(HLERequestContext& ct
     rb.Push(profile_manager->CanSystemRegisterUser());
 }
 
+void Module::Interface::InitializeApplicationInfo(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(InitializeApplicationInfoBase());
+}
+
+void Module::Interface::InitializeApplicationInfoRestricted(HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(Partial implementation) called");
+
+    // TODO(ogniK): We require checking if the user actually owns the title and what not. As of
+    // currently, we assume the user owns the title. InitializeApplicationInfoBase SHOULD be called
+    // first then we do extra checks if the game is a digital copy.
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(InitializeApplicationInfoBase());
+}
+
+Result Module::Interface::InitializeApplicationInfoBase() {
+    if (application_info) {
+        LOG_ERROR(Service_ACC, "Application already initialized");
+        return Account::ResultApplicationInfoAlreadyInitialized;
+    }
+
+    // TODO(ogniK): This should be changed to reflect the target process for when we have multiple
+    // processes emulated. As we don't actually have pid support we should assume we're just using
+    // our own process
+    Glue::ApplicationLaunchProperty launch_property{};
+    const auto result = system.GetARPManager().GetLaunchProperty(
+        &launch_property, system.GetApplicationProcessProgramID());
+
+    if (result != ResultSuccess) {
+        LOG_ERROR(Service_ACC, "Failed to get launch property");
+        return Account::ResultInvalidApplication;
+    }
+
+    switch (launch_property.base_game_storage_id) {
+    case StorageId::GameCard:
+        application_info.application_type = ApplicationType::GameCard;
+        break;
+    case StorageId::Host:
+    case StorageId::NandUser:
+    case StorageId::SdCard:
+    case StorageId::None: // Yuzu specific, differs from hardware
+        application_info.application_type = ApplicationType::Digital;
+        break;
+    default:
+        LOG_ERROR(Service_ACC, "Invalid game storage ID! storage_id={}",
+                  launch_property.base_game_storage_id);
+        return Account::ResultInvalidApplication;
+    }
+
+    LOG_WARNING(Service_ACC, "ApplicationInfo init required");
+    // TODO(ogniK): Actual initialization here
+    return ResultSuccess;
+}
+
 void Module::Interface::GetBaasAccountManagerForApplication(HLERequestContext& ctx) {
     LOG_DEBUG(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
     rb.PushIpcInterface<IManagerForApplication>(system, profile_manager);
 }
 
+void Module::Interface::IsUserAccountSwitchLocked(HLERequestContext& ctx) {
+    LOG_DEBUG(Service_ACC, "called");
+    UNIMPLEMENTED();
+}
+
 void Module::Interface::InitializeApplicationInfoV2(HLERequestContext& ctx) {
     LOG_WARNING(Service_ACC, "(STUBBED) called");
 

src/nxemu-os/core/hle/service/acc/acc.h

@@ -26,9 +26,12 @@ class Module final {
         void ListOpenUsers(HLERequestContext& ctx);
         void GetLastOpenedUser(HLERequestContext& ctx);
         void GetProfile(HLERequestContext& ctx);
+        void InitializeApplicationInfo(HLERequestContext& ctx);
+        void InitializeApplicationInfoRestricted(HLERequestContext& ctx);
         void GetBaasAccountManagerForApplication(HLERequestContext& ctx);
         void IsUserRegistrationRequestPermitted(HLERequestContext& ctx);
         void TrySelectUserWithoutInteraction(HLERequestContext& ctx);
+        void IsUserAccountSwitchLocked(HLERequestContext& ctx);
         void InitializeApplicationInfoV2(HLERequestContext& ctx);
         void BeginUserRegistration(HLERequestContext& ctx);
         void CompleteUserRegistration(HLERequestContext& ctx);
@@ -40,6 +43,7 @@ class Module final {
         void StoreSaveDataThumbnailSystem(HLERequestContext& ctx);
 
     private:
+        Result InitializeApplicationInfoBase();
         void StoreSaveDataThumbnail(HLERequestContext& ctx, const Common::UUID& uuid,
                                     const u64 tid);
 
@@ -49,6 +53,17 @@ class Module final {
             Unknown = 3,
         };
 
+        struct ApplicationInfo {
+            Service::Glue::ApplicationLaunchProperty launch_property;
+            ApplicationType application_type;
+
+            constexpr explicit operator bool() const {
+                return launch_property.title_id != 0x0;
+            }
+        };
+
+        ApplicationInfo application_info{};
+
     protected:
         std::shared_ptr<Module> module;
         std::shared_ptr<ProfileManager> profile_manager;

src/nxemu-os/core/hle/service/acc/acc_u0.cpp

@@ -21,6 +21,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, &ACC_U0::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"}, // 5.0.0 - 5.1.0
         {99, nullptr, "DebugActivateOpenContextRetention"}, // 6.0.0+
+        {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
         {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
         {102, nullptr, "AuthenticateApplicationAsync"},
         {103, nullptr, "CheckNetworkServiceAvailabilityAsync"}, // 4.0.0+
@@ -29,7 +30,9 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module_, std::shared_ptr<ProfileManager>
         {120, nullptr, "CreateGuestLoginRequest"},
         {130, nullptr, "LoadOpenContext"}, // 5.0.0+
         {131, &ACC_U0::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"}, // 6.0.0+
+        {140, &ACC_U0::InitializeApplicationInfoRestricted, "InitializeApplicationInfoRestricted"}, // 6.0.0+
         {141, &ACC_U0::ListQualifiedUsers, "ListQualifiedUsers"}, // 6.0.0+
+        {150, &ACC_U0::IsUserAccountSwitchLocked, "IsUserAccountSwitchLocked"}, // 6.0.0+
         {160, &ACC_U0::InitializeApplicationInfoV2, "InitializeApplicationInfoV2"},
     };
     // clang-format on