Merge pull request #1017 from ogniK5377/better-account

New account backend to allow for future extended support

13 files changed, 440 insertions, 74 deletions

diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 67ad6109a..31a7bf6fd 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -122,6 +122,8 @@ add_library(core STATIC
     hle/service/acc/acc_u0.h
     hle/service/acc/acc_u1.cpp
     hle/service/acc/acc_u1.h
+    hle/service/acc/profile_manager.cpp
+    hle/service/acc/profile_manager.h
     hle/service/am/am.cpp
     hle/service/am/am.h
     hle/service/am/applet_ae.cpp
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index f3c5b1b9c..979f2f892 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -3,7 +3,10 @@
 // Refer to the license.txt file included.
 
 #include <array>
+#include "common/common_types.h"
 #include "common/logging/log.h"
+#include "common/swap.h"
+#include "core/core_timing.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/acc/acc.h"
 #include "core/hle/service/acc/acc_aa.h"
@@ -13,7 +16,6 @@
 #include "core/settings.h"
 
 namespace Service::Account {
-
 // TODO: RE this structure
 struct UserData {
     INSERT_PADDING_WORDS(1);
@@ -25,19 +27,13 @@ struct UserData {
 };
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
 
-struct ProfileBase {
-    u128 user_id;
-    u64 timestamp;
-    std::array<u8, 0x20> username;
-};
-static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase structure has incorrect size");
-
 // TODO(ogniK): Generate a real user id based on username, md5(username) maybe?
-static constexpr u128 DEFAULT_USER_ID{1ull, 0ull};
+static UUID DEFAULT_USER_ID{1ull, 0ull};
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfile(u128 user_id) : ServiceFramework("IProfile"), user_id(user_id) {
+    explicit IProfile(UUID user_id, ProfileManager& profile_manager)
+        : ServiceFramework("IProfile"), user_id(user_id), profile_manager(profile_manager) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
             {1, &IProfile::GetBase, "GetBase"},
@@ -49,38 +45,34 @@ public:
 
 private:
     void Get(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
+        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
         ProfileBase profile_base{};
-        profile_base.user_id = user_id;
-        if (Settings::values.username.size() > profile_base.username.size()) {
-            std::copy_n(Settings::values.username.begin(), profile_base.username.size(),
-                        profile_base.username.begin());
+        std::array<u8, MAX_DATA> data{};
+        if (profile_manager.GetProfileBaseAndData(user_id, profile_base, data)) {
+            ctx.WriteBuffer(data);
+            IPC::ResponseBuilder rb{ctx, 16};
+            rb.Push(RESULT_SUCCESS);
+            rb.PushRaw(profile_base);
         } else {
-            std::copy(Settings::values.username.begin(), Settings::values.username.end(),
-                      profile_base.username.begin());
+            LOG_ERROR(Service_ACC, "Failed to get profile base and data for user={}",
+                      user_id.Format());
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ResultCode(-1)); // TODO(ogniK): Get actual error code
         }
-
-        IPC::ResponseBuilder rb{ctx, 16};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw(profile_base);
     }
 
     void GetBase(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-        // TODO(Subv): Retrieve this information from somewhere.
+        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
         ProfileBase profile_base{};
-        profile_base.user_id = user_id;
-        if (Settings::values.username.size() > profile_base.username.size()) {
-            std::copy_n(Settings::values.username.begin(), profile_base.username.size(),
-                        profile_base.username.begin());
+        if (profile_manager.GetProfileBase(user_id, profile_base)) {
+            IPC::ResponseBuilder rb{ctx, 16};
+            rb.Push(RESULT_SUCCESS);
+            rb.PushRaw(profile_base);
         } else {
-            std::copy(Settings::values.username.begin(), Settings::values.username.end(),
-                      profile_base.username.begin());
+            LOG_ERROR(Service_ACC, "Failed to get profile base for user={}", user_id.Format());
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ResultCode(-1)); // TODO(ogniK): Get actual error code
         }
-        IPC::ResponseBuilder rb{ctx, 16};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushRaw(profile_base);
     }
 
     void LoadImage(Kernel::HLERequestContext& ctx) {
@@ -104,7 +96,8 @@ private:
         rb.Push<u32>(jpeg_size);
     }
 
-    u128 user_id; ///< The user id this profile refers to.
+    const ProfileManager& profile_manager;
+    UUID user_id; ///< The user id this profile refers to.
 };
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
@@ -141,44 +134,57 @@ private:
 };
 
 void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    LOG_INFO(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(1);
+    rb.Push<u32>(static_cast<u32>(profile_manager->GetUserCount()));
 }
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    IPC::RequestParser rp{ctx};
+    UUID user_id = rp.PopRaw<UUID>();
+    LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
+
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(true); // TODO: Check when this is supposed to return true and when not
+    rb.Push(profile_manager->UserExists(user_id));
 }
 
 void Module::Interface::ListAllUsers(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    // TODO(Subv): There is only one user for now.
-    const std::vector<u128> user_ids = {DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids);
+    LOG_INFO(Service_ACC, "called");
+    ctx.WriteBuffer(profile_manager->GetAllUsers());
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
 void Module::Interface::ListOpenUsers(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    // TODO(Subv): There is only one user for now.
-    const std::vector<u128> user_ids = {DEFAULT_USER_ID};
-    ctx.WriteBuffer(user_ids);
+    LOG_INFO(Service_ACC, "called");
+    ctx.WriteBuffer(profile_manager->GetOpenUsers());
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
+void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
+    LOG_INFO(Service_ACC, "called");
+    IPC::ResponseBuilder rb{ctx, 6};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushRaw<UUID>(profile_manager->GetLastOpenedUser());
+}
+
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    u128 user_id = rp.PopRaw<u128>();
+    UUID user_id = rp.PopRaw<UUID>();
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IProfile>(user_id);
-    LOG_DEBUG(Service_ACC, "called user_id=0x{:016X}{:016X}", user_id[1], user_id[0]);
+    rb.PushIpcInterface<IProfile>(user_id, *profile_manager);
+    LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
+}
+
+void Module::Interface::IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_ACC, "(STUBBED) called");
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(profile_manager->CanSystemRegisterUser());
 }
 
 void Module::Interface::InitializeApplicationInfo(Kernel::HLERequestContext& ctx) {
@@ -194,22 +200,18 @@ void Module::Interface::GetBaasAccountManagerForApplication(Kernel::HLERequestCo
     LOG_DEBUG(Service_ACC, "called");
 }
 
-void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_ACC, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushRaw(DEFAULT_USER_ID);
-}
-
-Module::Interface::Interface(std::shared_ptr<Module> module, const char* name)
-    : ServiceFramework(name), module(std::move(module)) {}
+Module::Interface::Interface(std::shared_ptr<Module> module,
+                             std::shared_ptr<ProfileManager> profile_manager, const char* name)
+    : ServiceFramework(name), module(std::move(module)),
+      profile_manager(std::move(profile_manager)) {}
 
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
-    std::make_shared<ACC_AA>(module)->InstallAsService(service_manager);
-    std::make_shared<ACC_SU>(module)->InstallAsService(service_manager);
-    std::make_shared<ACC_U0>(module)->InstallAsService(service_manager);
-    std::make_shared<ACC_U1>(module)->InstallAsService(service_manager);
+    auto profile_manager = std::make_shared<ProfileManager>();
+    std::make_shared<ACC_AA>(module, profile_manager)->InstallAsService(service_manager);
+    std::make_shared<ACC_SU>(module, profile_manager)->InstallAsService(service_manager);
+    std::make_shared<ACC_U0>(module, profile_manager)->InstallAsService(service_manager);
+    std::make_shared<ACC_U1>(module, profile_manager)->InstallAsService(service_manager);
 }
 
 } // namespace Service::Account
diff --git a/src/core/hle/service/acc/acc.h b/src/core/hle/service/acc/acc.h
index 88cabaa01..d7c6d2415 100644
--- a/src/core/hle/service/acc/acc.h
+++ b/src/core/hle/service/acc/acc.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::Account {
@@ -12,7 +13,8 @@ class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
-        explicit Interface(std::shared_ptr<Module> module, const char* name);
+        explicit Interface(std::shared_ptr<Module> module,
+                           std::shared_ptr<ProfileManager> profile_manager, const char* name);
 
         void GetUserCount(Kernel::HLERequestContext& ctx);
         void GetUserExistence(Kernel::HLERequestContext& ctx);
@@ -22,9 +24,11 @@ public:
         void GetProfile(Kernel::HLERequestContext& ctx);
         void InitializeApplicationInfo(Kernel::HLERequestContext& ctx);
         void GetBaasAccountManagerForApplication(Kernel::HLERequestContext& ctx);
+        void IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx);
 
     protected:
         std::shared_ptr<Module> module;
+        std::shared_ptr<ProfileManager> profile_manager;
     };
 };
 
diff --git a/src/core/hle/service/acc/acc_aa.cpp b/src/core/hle/service/acc/acc_aa.cpp
index 280b3e464..9bd595a37 100644
--- a/src/core/hle/service/acc/acc_aa.cpp
+++ b/src/core/hle/service/acc/acc_aa.cpp
@@ -6,7 +6,8 @@
 
 namespace Service::Account {
 
-ACC_AA::ACC_AA(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:aa") {
+ACC_AA::ACC_AA(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:aa") {
     static const FunctionInfo functions[] = {
         {0, nullptr, "EnsureCacheAsync"},
         {1, nullptr, "LoadCache"},
diff --git a/src/core/hle/service/acc/acc_aa.h b/src/core/hle/service/acc/acc_aa.h
index 796f7ef85..2e08c781a 100644
--- a/src/core/hle/service/acc/acc_aa.h
+++ b/src/core/hle/service/acc/acc_aa.h
@@ -10,7 +10,8 @@ namespace Service::Account {
 
 class ACC_AA final : public Module::Interface {
 public:
-    explicit ACC_AA(std::shared_ptr<Module> module);
+    explicit ACC_AA(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
 };
 
 } // namespace Service::Account
diff --git a/src/core/hle/service/acc/acc_su.cpp b/src/core/hle/service/acc/acc_su.cpp
index 8b2a71f37..0218ee859 100644
--- a/src/core/hle/service/acc/acc_su.cpp
+++ b/src/core/hle/service/acc/acc_su.cpp
@@ -6,7 +6,8 @@
 
 namespace Service::Account {
 
-ACC_SU::ACC_SU(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:su") {
+ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:su") {
     static const FunctionInfo functions[] = {
         {0, &ACC_SU::GetUserCount, "GetUserCount"},
         {1, &ACC_SU::GetUserExistence, "GetUserExistence"},
@@ -15,7 +16,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module) : Module::Interface(std::move(mod
         {4, &ACC_SU::GetLastOpenedUser, "GetLastOpenedUser"},
         {5, &ACC_SU::GetProfile, "GetProfile"},
         {6, nullptr, "GetProfileDigest"},
-        {50, nullptr, "IsUserRegistrationRequestPermitted"},
+        {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, nullptr, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
         {100, nullptr, "GetUserRegistrationNotifier"},
diff --git a/src/core/hle/service/acc/acc_su.h b/src/core/hle/service/acc/acc_su.h
index 3894a6991..79a47d88d 100644
--- a/src/core/hle/service/acc/acc_su.h
+++ b/src/core/hle/service/acc/acc_su.h
@@ -11,7 +11,8 @@ namespace Account {
 
 class ACC_SU final : public Module::Interface {
 public:
-    explicit ACC_SU(std::shared_ptr<Module> module);
+    explicit ACC_SU(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
 };
 
 } // namespace Account
diff --git a/src/core/hle/service/acc/acc_u0.cpp b/src/core/hle/service/acc/acc_u0.cpp
index d84c8b2e1..84a4d05b8 100644
--- a/src/core/hle/service/acc/acc_u0.cpp
+++ b/src/core/hle/service/acc/acc_u0.cpp
@@ -6,7 +6,8 @@
 
 namespace Service::Account {
 
-ACC_U0::ACC_U0(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:u0") {
+ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:u0") {
     static const FunctionInfo functions[] = {
         {0, &ACC_U0::GetUserCount, "GetUserCount"},
         {1, &ACC_U0::GetUserExistence, "GetUserExistence"},
@@ -15,7 +16,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module) : Module::Interface(std::move(mod
         {4, &ACC_U0::GetLastOpenedUser, "GetLastOpenedUser"},
         {5, &ACC_U0::GetProfile, "GetProfile"},
         {6, nullptr, "GetProfileDigest"},
-        {50, nullptr, "IsUserRegistrationRequestPermitted"},
+        {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, nullptr, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
diff --git a/src/core/hle/service/acc/acc_u0.h b/src/core/hle/service/acc/acc_u0.h
index 6ded596b3..e8a114f99 100644
--- a/src/core/hle/service/acc/acc_u0.h
+++ b/src/core/hle/service/acc/acc_u0.h
@@ -10,7 +10,8 @@ namespace Service::Account {
 
 class ACC_U0 final : public Module::Interface {
 public:
-    explicit ACC_U0(std::shared_ptr<Module> module);
+    explicit ACC_U0(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
 };
 
 } // namespace Service::Account
diff --git a/src/core/hle/service/acc/acc_u1.cpp b/src/core/hle/service/acc/acc_u1.cpp
index 0ceaf06b5..495693949 100644
--- a/src/core/hle/service/acc/acc_u1.cpp
+++ b/src/core/hle/service/acc/acc_u1.cpp
@@ -6,7 +6,8 @@
 
 namespace Service::Account {
 
-ACC_U1::ACC_U1(std::shared_ptr<Module> module) : Module::Interface(std::move(module), "acc:u1") {
+ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
+    : Module::Interface(std::move(module), std::move(profile_manager), "acc:u1") {
     static const FunctionInfo functions[] = {
         {0, &ACC_U1::GetUserCount, "GetUserCount"},
         {1, &ACC_U1::GetUserExistence, "GetUserExistence"},
@@ -15,7 +16,7 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module) : Module::Interface(std::move(mod
         {4, &ACC_U1::GetLastOpenedUser, "GetLastOpenedUser"},
         {5, &ACC_U1::GetProfile, "GetProfile"},
         {6, nullptr, "GetProfileDigest"},
-        {50, nullptr, "IsUserRegistrationRequestPermitted"},
+        {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, nullptr, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
         {100, nullptr, "GetUserRegistrationNotifier"},
diff --git a/src/core/hle/service/acc/acc_u1.h b/src/core/hle/service/acc/acc_u1.h
index 5e3e7659b..a77520e6f 100644
--- a/src/core/hle/service/acc/acc_u1.h
+++ b/src/core/hle/service/acc/acc_u1.h
@@ -10,7 +10,8 @@ namespace Service::Account {
 
 class ACC_U1 final : public Module::Interface {
 public:
-    explicit ACC_U1(std::shared_ptr<Module> module);
+    explicit ACC_U1(std::shared_ptr<Module> module,
+                    std::shared_ptr<ProfileManager> profile_manager);
 };
 
 } // namespace Service::Account
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
new file mode 100644
index 000000000..62c2121fa
--- /dev/null
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -0,0 +1,226 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <boost/optional.hpp>
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/settings.h"
+
+namespace Service::Account {
+// TODO(ogniK): Get actual error codes
+constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, -1);
+constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, -2);
+constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
+
+ProfileManager::ProfileManager() {
+    // TODO(ogniK): Create the default user we have for now until loading/saving users is added
+    auto user_uuid = UUID{1, 0};
+    CreateNewUser(user_uuid, Settings::values.username);
+    OpenUser(user_uuid);
+}
+
+/// After a users creation it needs to be "registered" to the system. AddToProfiles handles the
+/// internal management of the users profiles
+boost::optional<size_t> ProfileManager::AddToProfiles(const ProfileInfo& user) {
+    if (user_count >= MAX_USERS) {
+        return boost::none;
+    }
+    profiles[user_count] = std::move(user);
+    return user_count++;
+}
+
+/// Deletes a specific profile based on it's profile index
+bool ProfileManager::RemoveProfileAtIndex(size_t index) {
+    if (index >= MAX_USERS || index >= user_count) {
+        return false;
+    }
+    if (index < user_count - 1) {
+        std::rotate(profiles.begin() + index, profiles.begin() + index + 1, profiles.end());
+    }
+    profiles.back() = {};
+    user_count--;
+    return true;
+}
+
+/// Helper function to register a user to the system
+ResultCode ProfileManager::AddUser(ProfileInfo user) {
+    if (AddToProfiles(user) == boost::none) {
+        return ERROR_TOO_MANY_USERS;
+    }
+    return RESULT_SUCCESS;
+}
+
+/// Create a new user on the system. If the uuid of the user already exists, the user is not
+/// created.
+ResultCode ProfileManager::CreateNewUser(UUID uuid, std::array<u8, 0x20>& username) {
+    if (user_count == MAX_USERS) {
+        return ERROR_TOO_MANY_USERS;
+    }
+    if (!uuid) {
+        return ERROR_ARGUMENT_IS_NULL;
+    }
+    if (username[0] == 0x0) {
+        return ERROR_ARGUMENT_IS_NULL;
+    }
+    if (std::any_of(profiles.begin(), profiles.end(),
+                    [&uuid](const ProfileInfo& profile) { return uuid == profile.user_uuid; })) {
+        return ERROR_USER_ALREADY_EXISTS;
+    }
+    ProfileInfo profile;
+    profile.user_uuid = std::move(uuid);
+    profile.username = username;
+    profile.data = {};
+    profile.creation_time = 0x0;
+    profile.is_open = false;
+    return AddUser(profile);
+}
+
+/// Creates a new user on the system. This function allows a much simpler method of registration
+/// specifically by allowing an std::string for the username. This is required specifically since
+/// we're loading a string straight from the config
+ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username) {
+    std::array<u8, 0x20> username_output;
+    if (username.size() > username_output.size()) {
+        std::copy_n(username.begin(), username_output.size(), username_output.begin());
+    } else {
+        std::copy(username.begin(), username.end(), username_output.begin());
+    }
+    return CreateNewUser(uuid, username_output);
+}
+
+/// Returns a users profile index based on their user id.
+boost::optional<size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
+    if (!uuid) {
+        return boost::none;
+    }
+    auto iter = std::find_if(profiles.begin(), profiles.end(),
+                             [&uuid](const ProfileInfo& p) { return p.user_uuid == uuid; });
+    if (iter == profiles.end()) {
+        return boost::none;
+    }
+    return static_cast<size_t>(std::distance(profiles.begin(), iter));
+}
+
+/// Returns a users profile index based on their profile
+boost::optional<size_t> ProfileManager::GetUserIndex(ProfileInfo user) const {
+    return GetUserIndex(user.user_uuid);
+}
+
+/// Returns the data structure used by the switch when GetProfileBase is called on acc:*
+bool ProfileManager::GetProfileBase(boost::optional<size_t> index, ProfileBase& profile) const {
+    if (index == boost::none || index >= MAX_USERS) {
+        return false;
+    }
+    const auto& prof_info = profiles[index.get()];
+    profile.user_uuid = prof_info.user_uuid;
+    profile.username = prof_info.username;
+    profile.timestamp = prof_info.creation_time;
+    return true;
+}
+
+/// Returns the data structure used by the switch when GetProfileBase is called on acc:*
+bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
+    auto idx = GetUserIndex(uuid);
+    return GetProfileBase(idx, profile);
+}
+
+/// Returns the data structure used by the switch when GetProfileBase is called on acc:*
+bool ProfileManager::GetProfileBase(ProfileInfo user, ProfileBase& profile) const {
+    return GetProfileBase(user.user_uuid, profile);
+}
+
+/// Returns the current user count on the system. We keep a variable which tracks the count so we
+/// don't have to loop the internal profile array every call.
+size_t ProfileManager::GetUserCount() const {
+    return user_count;
+}
+
+/// Lists the current "opened" users on the system. Users are typically not open until they sign
+/// into something or pick a profile. As of right now users should all be open until qlaunch is
+/// booting
+size_t ProfileManager::GetOpenUserCount() const {
+    return std::count_if(profiles.begin(), profiles.end(),
+                         [](const ProfileInfo& p) { return p.is_open; });
+}
+
+/// Checks if a user id exists in our profile manager
+bool ProfileManager::UserExists(UUID uuid) const {
+    return (GetUserIndex(uuid) != boost::none);
+}
+
+/// Opens a specific user
+void ProfileManager::OpenUser(UUID uuid) {
+    auto idx = GetUserIndex(uuid);
+    if (idx == boost::none) {
+        return;
+    }
+    profiles[idx.get()].is_open = true;
+    last_opened_user = uuid;
+}
+
+/// Closes a specific user
+void ProfileManager::CloseUser(UUID uuid) {
+    auto idx = GetUserIndex(uuid);
+    if (idx == boost::none) {
+        return;
+    }
+    profiles[idx.get()].is_open = false;
+}
+
+/// Gets all valid user ids on the system
+std::array<UUID, MAX_USERS> ProfileManager::GetAllUsers() const {
+    std::array<UUID, MAX_USERS> output;
+    std::transform(profiles.begin(), profiles.end(), output.begin(),
+                   [](const ProfileInfo& p) { return p.user_uuid; });
+    return output;
+}
+
+/// Get all the open users on the system and zero out the rest of the data. This is specifically
+/// needed for GetOpenUsers and we need to ensure the rest of the output buffer is zero'd out
+std::array<UUID, MAX_USERS> ProfileManager::GetOpenUsers() const {
+    std::array<UUID, MAX_USERS> output;
+    std::transform(profiles.begin(), profiles.end(), output.begin(), [](const ProfileInfo& p) {
+        if (p.is_open)
+            return p.user_uuid;
+        return UUID{};
+    });
+    std::stable_partition(output.begin(), output.end(), [](const UUID& uuid) { return uuid; });
+    return output;
+}
+
+/// Returns the last user which was opened
+UUID ProfileManager::GetLastOpenedUser() const {
+    return last_opened_user;
+}
+
+/// Return the users profile base and the unknown arbitary data.
+bool ProfileManager::GetProfileBaseAndData(boost::optional<size_t> index, ProfileBase& profile,
+                                           std::array<u8, MAX_DATA>& data) const {
+    if (GetProfileBase(index, profile)) {
+        std::memcpy(data.data(), profiles[index.get()].data.data(), MAX_DATA);
+        return true;
+    }
+    return false;
+}
+
+/// Return the users profile base and the unknown arbitary data.
+bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
+                                           std::array<u8, MAX_DATA>& data) const {
+    auto idx = GetUserIndex(uuid);
+    return GetProfileBaseAndData(idx, profile, data);
+}
+
+/// Return the users profile base and the unknown arbitary data.
+bool ProfileManager::GetProfileBaseAndData(ProfileInfo user, ProfileBase& profile,
+                                           std::array<u8, MAX_DATA>& data) const {
+    return GetProfileBaseAndData(user.user_uuid, profile, data);
+}
+
+/// Returns if the system is allowing user registrations or not
+bool ProfileManager::CanSystemRegisterUser() const {
+    return false; // TODO(ogniK): Games shouldn't have
+                  // access to user registration, when we
+    // emulate qlaunch. Update this to dynamically change.
+}
+
+}; // namespace Service::Account
diff --git a/src/core/hle/service/acc/profile_manager.h b/src/core/hle/service/acc/profile_manager.h
new file mode 100644
index 000000000..314bccbf9
--- /dev/null
+++ b/src/core/hle/service/acc/profile_manager.h
@@ -0,0 +1,124 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <random>
+#include "boost/optional.hpp"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/hle/result.h"
+
+namespace Service::Account {
+constexpr size_t MAX_USERS = 8;
+constexpr size_t MAX_DATA = 128;
+static const u128 INVALID_UUID = {0, 0};
+
+struct UUID {
+    // UUIDs which are 0 are considered invalid!
+    u128 uuid = INVALID_UUID;
+    UUID() = default;
+    explicit UUID(const u128& id) : uuid{id} {}
+    explicit UUID(const u64 lo, const u64 hi) {
+        uuid[0] = lo;
+        uuid[1] = hi;
+    };
+    explicit operator bool() const {
+        return uuid[0] != INVALID_UUID[0] || uuid[1] != INVALID_UUID[1];
+    }
+
+    bool operator==(const UUID& rhs) const {
+        return std::tie(uuid[0], uuid[1]) == std::tie(rhs.uuid[0], rhs.uuid[1]);
+    }
+
+    bool operator!=(const UUID& rhs) const {
+        return !operator==(rhs);
+    }
+
+    // TODO(ogniK): Properly generate uuids based on RFC-4122
+    const UUID& Generate() {
+        std::random_device device;
+        std::mt19937 gen(device());
+        std::uniform_int_distribution<uint64_t> distribution(1,
+                                                             std::numeric_limits<uint64_t>::max());
+        uuid[0] = distribution(gen);
+        uuid[1] = distribution(gen);
+        return *this;
+    }
+
+    // Set the UUID to {0,0} to be considered an invalid user
+    void Invalidate() {
+        uuid = INVALID_UUID;
+    }
+    std::string Format() const {
+        return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
+    }
+};
+static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
+
+/// This holds general information about a users profile. This is where we store all the information
+/// based on a specific user
+struct ProfileInfo {
+    UUID user_uuid;
+    std::array<u8, 0x20> username;
+    u64 creation_time;
+    std::array<u8, MAX_DATA> data; // TODO(ognik): Work out what this is
+    bool is_open;
+};
+
+struct ProfileBase {
+    UUID user_uuid;
+    u64_le timestamp;
+    std::array<u8, 0x20> username;
+
+    // Zero out all the fields to make the profile slot considered "Empty"
+    void Invalidate() {
+        user_uuid.Invalidate();
+        timestamp = 0;
+        username.fill(0);
+    }
+};
+static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase is an invalid size");
+
+/// The profile manager is used for handling multiple user profiles at once. It keeps track of open
+/// users, all the accounts registered on the "system" as well as fetching individual "ProfileInfo"
+/// objects
+class ProfileManager {
+public:
+    ProfileManager(); // TODO(ogniK): Load from system save
+    ResultCode AddUser(ProfileInfo user);
+    ResultCode CreateNewUser(UUID uuid, std::array<u8, 0x20>& username);
+    ResultCode CreateNewUser(UUID uuid, const std::string& username);
+    boost::optional<size_t> GetUserIndex(const UUID& uuid) const;
+    boost::optional<size_t> GetUserIndex(ProfileInfo user) const;
+    bool GetProfileBase(boost::optional<size_t> index, ProfileBase& profile) const;
+    bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
+    bool GetProfileBase(ProfileInfo user, ProfileBase& profile) const;
+    bool GetProfileBaseAndData(boost::optional<size_t> index, ProfileBase& profile,
+                               std::array<u8, MAX_DATA>& data) const;
+    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
+                               std::array<u8, MAX_DATA>& data) const;
+    bool GetProfileBaseAndData(ProfileInfo user, ProfileBase& profile,
+                               std::array<u8, MAX_DATA>& data) const;
+    size_t GetUserCount() const;
+    size_t GetOpenUserCount() const;
+    bool UserExists(UUID uuid) const;
+    void OpenUser(UUID uuid);
+    void CloseUser(UUID uuid);
+    std::array<UUID, MAX_USERS> GetOpenUsers() const;
+    std::array<UUID, MAX_USERS> GetAllUsers() const;
+    UUID GetLastOpenedUser() const;
+
+    bool CanSystemRegisterUser() const;
+
+private:
+    std::array<ProfileInfo, MAX_USERS> profiles{};
+    size_t user_count = 0;
+    boost::optional<size_t> AddToProfiles(const ProfileInfo& profile);
+    bool RemoveProfileAtIndex(size_t index);
+    UUID last_opened_user{0, 0};
+};
+
+}; // namespace Service::Account