Fixed flat functions

.github/workflows/ci.yml

@@ -4,7 +4,7 @@ on: push
 jobs:
   ci:
     name: CI
-    uses: acidicoala/KoalaBox/.github/workflows/build-and-package.yml@a1a8661947cc3260ed217ec75fb8cf15825cdf6e
+    uses: acidicoala/KoalaBox/.github/workflows/build-and-package.yml@d9b0d1a00beb065a9a931a60ef615ce8d1fc7164
     permissions:
       contents: write
     with:

.idea/cmake.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CMakeSharedSettings">
-    <configurations>
-      <configuration PROFILE_NAME="Debug [32]" ENABLED="true" GENERATION_DIR="build/32" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Visual Studio 2022 [x86]" GENERATION_OPTIONS="-G &quot;Visual Studio 17 2022&quot; -A Win32" />
-      <configuration PROFILE_NAME="Debug [64]" ENABLED="true" GENERATION_DIR="build/64" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Visual Studio 2022 [amd64]" GENERATION_OPTIONS="-G &quot;Visual Studio 17 2022&quot; -A x64" />
-      <configuration PROFILE_NAME="Relase [64]" ENABLED="false" GENERATION_DIR="build/64/release" CONFIG_NAME="Release" TOOLCHAIN_NAME="Visual Studio 2022 [amd64]" GENERATION_OPTIONS="-G &quot;Visual Studio 17 2022&quot; -A x64" />
-    </configurations>
-  </component>
-</project>

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.22)
 
-project(SmokeAPI VERSION 1.0.0)
+project(SmokeAPI VERSION 1.0.2)
 
 include(KoalaBox/cmake/KoalaBox.cmake)
 
@@ -53,11 +53,23 @@ set(
     src/steam_functions/steam_functions.hpp
     src/steam_types/steam_types.hpp
     src/steamclient_exports/steamclient.cpp
-    src/vstdlib/vstdlib.cpp
     src/main.cpp
     ${GENERATED_LINKER_EXPORTS}
 )
 
+if (CMAKE_SIZEOF_VOID_P EQUAL 4)
+    set(
+        SMOKE_API_SOURCES ${SMOKE_API_SOURCES}
+        src/koalageddon/vstdlib.cpp
+        src/koalageddon/steamclient.cpp
+        src/steamclient_virtuals/client_app_manager.cpp
+        src/steamclient_virtuals/client_apps.cpp
+        src/steamclient_virtuals/client_inventory.cpp
+        src/steamclient_virtuals/client_user.cpp
+        src/steamclient_virtuals/client_utils.cpp
+    )
+endif ()
+
 add_library(SmokeAPI SHARED ${SMOKE_API_SOURCES} ${VERSION_RESOURCE})
 
 configure_output_name(${ORIGINAL_DLL})

src/koalageddon/steamclient.cpp

@@ -0,0 +1,58 @@
+#include <smoke_api/smoke_api.hpp>
+#include <steam_functions/steam_functions.hpp>
+
+#include <koalabox/hook.hpp>
+
+using namespace smoke_api;
+
+
+DLL_EXPORT(void) Log_Interface(const char* interface_name, const char* function_name) {
+    try {
+        void**** parent_ebp;
+
+        __asm mov parent_ebp, ebp
+
+        auto* interface_address = (*parent_ebp)[2];
+
+        static Set<String> hooked_functions;
+
+        auto hook_function = [&](const auto hook_function, const String& name, const int ordinal) {
+            if (hooked_functions.contains(name)) {
+                return;
+            }
+
+            hook::swap_virtual_func_or_throw(interface_address, name, ordinal, (FunctionAddress) (hook_function));
+
+            hooked_functions.insert(name);
+        };
+
+        const auto compound_name = interface_name + String("::") + function_name;
+
+#define HOOK(FUNC, ORDINAL) hook_function(FUNC, #FUNC, ORDINAL);
+
+        if (compound_name == "IClientAppManager::IsAppDlcInstalled") {
+            HOOK(IClientAppManager_IsAppDlcInstalled, 8)
+        } else if (compound_name == "IClientApps::GetDLCCount") {
+            HOOK(IClientApps_GetDLCCount, 8)
+        } else if (compound_name == "IClientApps::BGetDLCDataByIndex") {
+            HOOK(IClientApps_BGetDLCDataByIndex, 9)
+        } else if (compound_name == "IClientUser::IsSubscribedApp") {
+            HOOK(IClientUser_IsSubscribedApp, 0xB5)
+        } else if (util::strings_are_equal(interface_name, "IClientInventory")) {
+            if (util::strings_are_equal(function_name, "GetResultItems")) {
+                auto* function_address = interface_address[0x2]; // TODO: Un-hardcode
+                logger->debug("{} -> {}::{} @ {}", __func__, interface_name, function_name, function_address);
+            }
+        } else if (util::strings_are_equal(interface_name, "IClientUtils")) {
+            if (util::strings_are_equal(function_name, "GetAppID")) {
+                auto* function_address = interface_address[0x12]; // TODO: Un-hardcode
+                logger->debug("{} -> {}::{} @ {}", __func__, interface_name, function_name, function_address);
+            }
+        }
+
+        GET_ORIGINAL_FUNCTION(Log_Interface)
+        Log_Interface_o(interface_name, function_name);
+    } catch (const Exception& ex) {
+        logger->error("{} -> Error: {}", __func__, ex.what());
+    }
+}

src/smoke_api/smoke_api.cpp

@@ -2,13 +2,17 @@
 #include <steam_functions/steam_functions.hpp>
 #include <build_config.h>
 
-#include <koalabox/loader.hpp>
 #include <koalabox/config_parser.hpp>
-#include <koalabox/file_logger.hpp>
-#include <koalabox/win_util.hpp>
-#include <koalabox/hook.hpp>
 #include <koalabox/dll_monitor.hpp>
+#include <koalabox/file_logger.hpp>
+#include <koalabox/hook.hpp>
+#include <koalabox/loader.hpp>
+#include <koalabox/win_util.hpp>
+#ifndef _WIN64
+#include <koalabox/patcher.hpp>
+#endif
 
+#define DETOUR_EX(FUNC, ADDRESS) hook::detour_or_warn(ADDRESS, #FUNC, reinterpret_cast<FunctionAddress>(FUNC));
 #define DETOUR(FUNC) hook::detour_or_warn(original_library, #FUNC, reinterpret_cast<FunctionAddress>(FUNC));
 
 namespace smoke_api {
@@ -47,14 +51,29 @@ namespace smoke_api {
             if (is_hook_mode) {
                 hook::init(true);
 
-                if (util::strings_are_equal(exe_name, "steam.exe")) { // target vstdlib_s.dll
+                if (util::strings_are_equal(exe_name, "steam.exe")) {
+#ifndef _WIN64
                     logger->info("🐨 Detected Koalageddon mode 💥");
 
-                    dll_monitor::init(VSTDLIB_DLL, [](const HMODULE& library) {
+                    dll_monitor::init({VSTDLIB_DLL, STEAMCLIENT_DLL}, [](const HMODULE& library, const String& name) {
-                        original_library = library;
+                        original_library = library; // TODO: Is this necessary?
 
-                        DETOUR(Coroutine_Create)
+                        if (name == VSTDLIB_DLL) {
+                            // Family Sharing functions
+                            DETOUR(Coroutine_Create)
+                        } else if (name == STEAMCLIENT_DLL) {
+                            // Unlocking functions
+                            // TODO: Un-hardcode the pattern
+                            const String pattern("55 8B EC 8B ?? ?? ?? ?? ?? 81 EC ?? ?? ?? ?? 53 FF 15");
+                            auto Log_Interface_address = (FunctionAddress) patcher::find_pattern_address(
+                                win_util::get_module_info(library), "Log_Interface", pattern
+                            );
+                            if (Log_Interface_address) {
+                                DETOUR_EX(Log_Interface, Log_Interface_address)
+                            }
+                        }
                     });
+#endif
                 } else if (config.hook_steamclient) { // target steamclient(64).dll
                     logger->info("🪝 Detected hook mode for SteamClient");
 
@@ -116,8 +135,8 @@ namespace smoke_api {
         }
     }
 
-    bool should_unlock(uint32_t appId) {
+    bool should_unlock(uint32_t app_id) {
-        return config.unlock_all != config.override.contains(appId);
+        return config.unlock_all != config.override.contains(app_id);
     }
 
 }

src/smoke_api/smoke_api.hpp

@@ -58,6 +58,6 @@ namespace smoke_api {
 
     void shutdown();
 
-    bool should_unlock(uint32_t appId);
+    bool should_unlock(uint32_t app_id);
 
 }

src/steam_api_exports/steam_api_flat.cpp

@@ -6,15 +6,15 @@ using namespace smoke_api;
 // ISteamApps
 
 DLL_EXPORT(bool) SteamAPI_ISteamApps_BIsSubscribedApp(ISteamApps*, AppId_t appID) {
-    return steam_apps::IsSubscribedApp(__func__, appID);
+    return steam_apps::IsDlcUnlocked(__func__, 0, appID);
 }
 
 DLL_EXPORT(bool) SteamAPI_ISteamApps_BIsDlcInstalled(ISteamApps*, AppId_t appID) {
-    return steam_apps::IsDlcInstalled(__func__, appID);
+    return steam_apps::IsDlcUnlocked(__func__, 0, appID);
 }
 
 DLL_EXPORT(int) SteamAPI_ISteamApps_GetDLCCount(ISteamApps* self) {
-    return steam_apps::GetDLCCount(__func__, [&]() {
+    return steam_apps::GetDLCCount(__func__, 0, [&]() {
         GET_ORIGINAL_FUNCTION(SteamAPI_ISteamApps_GetDLCCount)
 
         return SteamAPI_ISteamApps_GetDLCCount_o(self);
@@ -29,7 +29,7 @@ DLL_EXPORT(bool) SteamAPI_ISteamApps_BGetDLCDataByIndex(
     char* pchName,
     int cchNameBufferSize
 ) {
-    return steam_apps::GetDLCDataByIndex(__func__, iDLC, pAppID, pbAvailable, pchName, cchNameBufferSize, [&]() {
+    return steam_apps::GetDLCDataByIndex(__func__, 0, iDLC, pAppID, pbAvailable, pchName, cchNameBufferSize, [&]() {
         GET_ORIGINAL_FUNCTION(SteamAPI_ISteamApps_BGetDLCDataByIndex)
 
         return SteamAPI_ISteamApps_BGetDLCDataByIndex_o(
@@ -111,7 +111,7 @@ DLL_EXPORT(bool) SteamAPI_ISteamInventory_GetResultItemProperty(
 ) {
     return steam_inventory::GetResultItemProperty(
         __func__, resultHandle, unItemIndex, pchPropertyName, pchValueBuffer, punValueBufferSizeOut, [&]() {
-            GET_ORIGINAL_VIRTUAL_FUNCTION(SteamAPI_ISteamInventory_GetResultItemProperty)
+            GET_ORIGINAL_FUNCTION(SteamAPI_ISteamInventory_GetResultItemProperty)
 
             return SteamAPI_ISteamInventory_GetResultItemProperty_o(
                 self, resultHandle, unItemIndex, pchPropertyName, pchValueBuffer, punValueBufferSizeOut
@@ -126,7 +126,7 @@ DLL_EXPORT(bool) SteamAPI_ISteamInventory_CheckResultSteamID(
     CSteamID steamIDExpected
 ) {
     return steam_inventory::CheckResultSteamID(__func__, resultHandle, steamIDExpected, [&]() {
-        GET_ORIGINAL_VIRTUAL_FUNCTION(SteamAPI_ISteamInventory_CheckResultSteamID)
+        GET_ORIGINAL_FUNCTION(SteamAPI_ISteamInventory_CheckResultSteamID)
 
         return SteamAPI_ISteamInventory_CheckResultSteamID_o(self, resultHandle, steamIDExpected);
     });

src/steam_api_virtuals/isteamapps.cpp

@@ -4,15 +4,15 @@
 using namespace smoke_api;
 
 VIRTUAL(bool) ISteamApps_BIsSubscribedApp(PARAMS(AppId_t appID)) { // NOLINT(misc-unused-parameters)
-    return steam_apps::IsSubscribedApp(__func__, appID);
+    return steam_apps::IsDlcUnlocked(__func__, 0, appID);
 }
 
 VIRTUAL(bool) ISteamApps_BIsDlcInstalled(PARAMS(AppId_t appID)) { // NOLINT(misc-unused-parameters)
-    return steam_apps::IsDlcInstalled(__func__, appID);
+    return steam_apps::IsDlcUnlocked(__func__, 0, appID);
 }
 
 VIRTUAL(int) ISteamApps_GetDLCCount(PARAMS()) {
-    return steam_apps::GetDLCCount(__func__, [&]() {
+    return steam_apps::GetDLCCount(__func__, 0, [&]() {
         GET_ORIGINAL_VIRTUAL_FUNCTION(ISteamApps_GetDLCCount)
 
         return ISteamApps_GetDLCCount_o(ARGS());
@@ -28,7 +28,7 @@ VIRTUAL(bool) ISteamApps_BGetDLCDataByIndex(
         int cchNameBufferSize
     )
 ) {
-    return steam_apps::GetDLCDataByIndex(__func__, iDLC, pAppID, pbAvailable, pchName, cchNameBufferSize, [&]() {
+    return steam_apps::GetDLCDataByIndex(__func__, 0, iDLC, pAppID, pbAvailable, pchName, cchNameBufferSize, [&]() {
         GET_ORIGINAL_VIRTUAL_FUNCTION(ISteamApps_BGetDLCDataByIndex)
 
         return ISteamApps_BGetDLCDataByIndex_o(

src/steam_functions/steam_functions.hpp

@@ -118,9 +118,20 @@ DLL_EXPORT(bool) SteamAPI_ISteamInventory_GetItemDefinitionProperty(
     ISteamInventory*, SteamItemDef_t, const char*, char*, uint32_t*
 );
 
-// vstdlib
+// koalageddon
 
 DLL_EXPORT(HCoroutine) Coroutine_Create(void* callback_address, struct CoroutineData* data);
+DLL_EXPORT(void) Log_Interface(const char* interface_name, const char* function_name);
+
+// IClientApps
+VIRTUAL(int) IClientApps_GetDLCCount(PARAMS(AppId_t));
+VIRTUAL(bool) IClientApps_BGetDLCDataByIndex(PARAMS(AppId_t, int, AppId_t*, bool*, char*, int));
+
+// IClientAppManager
+VIRTUAL(bool) IClientAppManager_IsAppDlcInstalled(PARAMS(AppId_t, AppId_t));
+
+// IClientUser
+VIRTUAL(bool) IClientUser_IsSubscribedApp(PARAMS(AppId_t));
 
 namespace steam_functions {
     using namespace koalabox;

src/steam_impl/steam_apps.cpp

@@ -51,14 +51,15 @@ void save_to_cache(const String& app_id_str) {
     }
 }
 
-void fetch_and_cache_dlcs() {
+void fetch_and_cache_dlcs(AppId_t app_id) {
-    uint32_t app_id;
+    if (not app_id) {
-    try {
+        try {
-        app_id = steam_functions::get_app_id_or_throw();
+            app_id = steam_functions::get_app_id_or_throw();
-        logger->info("Detected App ID: {}", app_id);
+            logger->info("Detected App ID: {}", app_id);
-    } catch (const Exception& ex) {
+        } catch (const Exception& ex) {
-        logger->error("Failed to get app ID: {}", ex.what());
+            logger->error("Failed to get app ID: {}", ex.what());
-        return;
+            return;
+        }
     }
 
     const auto app_id_str = std::to_string(app_id);
@@ -131,29 +132,31 @@ void fetch_and_cache_dlcs() {
     }
 }
 
+String get_app_id_log(const AppId_t app_id) {
+    return app_id ? fmt::format("App ID: {}, ", app_id) : "";
+}
 
-namespace steam_apps{
+namespace steam_apps {
 
-    bool IsSubscribedApp(const String& function_name, AppId_t appID) {
+    bool IsDlcUnlocked(const String& function_name, AppId_t app_id, AppId_t dlc_id) {
-        const auto subscribed = should_unlock(appID);
+        const auto app_id_unlocked = not app_id or should_unlock(app_id); // true if app_id == 0
+        const auto dlc_id_unlocked = should_unlock(dlc_id);
 
-        logger->info("{} -> App ID: {}, Subscribed: {}", function_name, appID, subscribed);
+        const auto installed = app_id_unlocked and dlc_id_unlocked;
 
-        return subscribed;
+        logger->info("{} -> {}DLC ID: {}, Unlocked: {}", function_name, get_app_id_log(app_id), dlc_id, installed);
-    }
-
-    bool IsDlcInstalled(const String& function_name, AppId_t appID) {
-        const auto installed = should_unlock(appID);
-
-        logger->info("{} -> App ID: {}, Installed: {}", function_name, appID, installed);
 
         return installed;
     }
 
-    int GetDLCCount(const String& function_name, const std::function<int()>& original_function) {
+    int GetDLCCount(const String& function_name, const AppId_t app_id, const std::function<int()>& original_function) {
         static std::mutex section;
         std::lock_guard<std::mutex> guard(section);
 
+        if (app_id) {
+            logger->debug("{} -> App ID: {}", function_name, app_id);
+        }
+
         // Compute count only once
         static int total_count = [&]() {
             original_dlc_count = original_function();
@@ -171,7 +174,7 @@ namespace steam_apps{
             }
 
             logger->debug("Game has {} or more DLCs. Fetching DLCs from a web API.", max_dlc);
-            fetch_and_cache_dlcs();
+            fetch_and_cache_dlcs(app_id);
 
             const auto fetched_count = static_cast<int>(cached_dlcs.size());
             logger->debug("{} -> Fetched/cached DLC count: {}", function_name, fetched_count);
@@ -186,8 +189,9 @@ namespace steam_apps{
 
     bool GetDLCDataByIndex(
         const String& function_name,
+        AppId_t app_id,
         int iDLC,
-        AppId_t* pAppID,
+        AppId_t* pDlcId,
         bool* pbAvailable,
         char* pchName,
         int cchNameBufferSize,
@@ -195,13 +199,13 @@ namespace steam_apps{
     ) {
         const auto print_dlc_info = [&](const String& tag) {
             logger->info(
-                "{} -> [{}] index: {}, App ID: {}, available: {}, name: '{}'",
+                "{} -> [{}] {}index: {}, DLC ID: {}, available: {}, name: '{}'",
-                function_name, tag, iDLC, *pAppID, *pbAvailable, pchName
+                function_name, tag, get_app_id_log(app_id), iDLC, *pDlcId, *pbAvailable, pchName
             );
         };
 
         const auto fill_dlc_info = [&](const AppId_t id) {
-            *pAppID = id;
+            *pDlcId = id;
             *pbAvailable = should_unlock(id);
 
             auto name = fmt::format("DLC #{} with ID: {} ", iDLC, id);
@@ -216,8 +220,8 @@ namespace steam_apps{
                 return false;
             }
 
-            const auto app_id = config.dlc_ids[index];
+            const auto dlc_id = config.dlc_ids[index];
-            fill_dlc_info(app_id);
+            fill_dlc_info(dlc_id);
             print_dlc_info("injected");
             return true;
         };
@@ -229,7 +233,7 @@ namespace steam_apps{
                 const auto success = original_function();
 
                 if (success) {
-                    *pbAvailable = should_unlock(*pAppID);
+                    *pbAvailable = should_unlock(*pDlcId);
                     print_dlc_info("original");
                 } else {
                     logger->warn("{} -> original function failed for index: {}", function_name, iDLC);
@@ -254,8 +258,8 @@ namespace steam_apps{
 
         // Cached index
         if (iDLC < cached_dlcs.size()) {
-            const auto app_id = cached_dlcs[iDLC];
+            const auto dlc_id = cached_dlcs[iDLC];
-            fill_dlc_info(app_id);
+            fill_dlc_info(dlc_id);
             print_dlc_info("cached");
             return true;
         }

src/steam_impl/steam_impl.hpp

@@ -4,16 +4,15 @@ using namespace koalabox;
 
 namespace steam_apps {
 
-    bool IsSubscribedApp(const String& function_name, AppId_t appID);
+    bool IsDlcUnlocked(const String& function_name, AppId_t app_id, AppId_t dlc_id);
 
-    bool IsDlcInstalled(const String& function_name, AppId_t appID);
+    int GetDLCCount(const String& function_name, AppId_t app_id, const std::function<int()>& original_function);
-
-    int GetDLCCount(const String& function_name, const std::function<int()>& original_function);
 
     bool GetDLCDataByIndex(
         const String& function_name,
+        AppId_t app_id,
         int iDLC,
-        AppId_t* pAppID,
+        AppId_t* pDlcId,
         bool* pbAvailable,
         char* pchName,
         int cchNameBufferSize,

src/steamclient_virtuals/client_app_manager.cpp

@@ -0,0 +1,13 @@
+#include <smoke_api/smoke_api.hpp>
+#include <steam_impl/steam_impl.hpp>
+
+using namespace smoke_api;
+
+VIRTUAL(bool) IClientAppManager_IsAppDlcInstalled(
+    PARAMS( // NOLINT(misc-unused-parameters)
+        AppId_t app_id,
+        AppId_t dlc_id
+    )
+) {
+    return steam_apps::IsDlcUnlocked(__func__, app_id, dlc_id);
+}

src/steamclient_virtuals/client_apps.cpp

@@ -0,0 +1,31 @@
+#include <smoke_api/smoke_api.hpp>
+#include <steam_impl/steam_impl.hpp>
+
+using namespace smoke_api;
+
+VIRTUAL(int) IClientApps_GetDLCCount(PARAMS(AppId_t appId)) {
+    return steam_apps::GetDLCCount(__func__, appId, [&]() {
+        GET_ORIGINAL_VIRTUAL_FUNCTION(IClientApps_GetDLCCount)
+
+        return IClientApps_GetDLCCount_o(ARGS(appId));
+    });
+}
+
+VIRTUAL(bool) IClientApps_BGetDLCDataByIndex(
+    PARAMS(
+        AppId_t appID,
+        int iDLC,
+        AppId_t* pDlcID,
+        bool* pbAvailable,
+        char* pchName,
+        int cchNameBufferSize
+    )
+) {
+    return steam_apps::GetDLCDataByIndex(__func__, appID, iDLC, pDlcID, pbAvailable, pchName, cchNameBufferSize, [&]() {
+        GET_ORIGINAL_VIRTUAL_FUNCTION(IClientApps_BGetDLCDataByIndex)
+
+        return IClientApps_BGetDLCDataByIndex_o(
+            ARGS(appID, iDLC, pDlcID, pbAvailable, pchName, cchNameBufferSize)
+        );
+    });
+}

src/steamclient_virtuals/client_user.cpp

@@ -0,0 +1,8 @@
+#include <smoke_api/smoke_api.hpp>
+#include <steam_impl/steam_impl.hpp>
+
+using namespace smoke_api;
+
+VIRTUAL(bool) IClientUser_IsSubscribedApp(PARAMS(AppId_t app_id)) { // NOLINT(misc-unused-parameters)
+    return steam_apps::IsDlcUnlocked(__func__, 0, app_id);
+}