Rename PluginInformation to PluginLinkInformation and make it optional in PluginContainer

source/PluginManagement.cpp

@@ -2,7 +2,7 @@
 #include "NotificationsUtils.h"
 #include "hooks.h"
 #include "plugin/PluginContainer.h"
-#include "plugin/PluginInformationFactory.h"
+#include "plugin/PluginLinkInformationFactory.h"
 #include "plugin/PluginMetaInformationFactory.h"
 #include "utils/ElfUtils.h"
 #include "utils/StringTools.h"
@@ -22,14 +22,14 @@ PluginManagement::loadPlugins(const std::set<std::shared_ptr<PluginData>> &plugi
 
         auto metaInfo = PluginMetaInformationFactory::loadPlugin(*pluginData, error);
         if (metaInfo && error == PLUGIN_PARSE_ERROR_NONE) {
-            auto info = PluginInformationFactory::load(*pluginData, trampolineData, trampolineID++);
+            auto linkInfo = PluginLinkInformationFactory::load(*pluginData, trampolineData, trampolineID++);
-            if (!info) {
+            if (!linkInfo) {
                 auto errMsg = string_format("Failed to load plugin: %s", pluginData->getSource().c_str());
                 DEBUG_FUNCTION_LINE_ERR("%s", errMsg.c_str());
                 DisplayErrorNotificationMessage(errMsg, 15.0f);
                 continue;
             }
-            plugins.emplace_back(std::move(*metaInfo), std::move(*info), pluginData);
+            plugins.emplace_back(std::move(*metaInfo), std::move(linkInfo), pluginData);
         } else {
             auto errMsg = string_format("Failed to load plugin: %s", pluginData->getSource().c_str());
             if (error == PLUGIN_PARSE_ERROR_INCOMPATIBLE_VERSION) {
@@ -137,10 +137,13 @@ bool PluginManagement::doRelocations(const std::vector<PluginContainer> &plugins
     OSDynLoad_SetAllocator(CustomDynLoadAlloc, CustomDynLoadFree);
 
     for (const auto &pluginContainer : plugins) {
+        if (!pluginContainer.isPluginLinkedAndLoaded()) {
+            continue;
+        }
         DEBUG_FUNCTION_LINE_VERBOSE("Doing relocations for plugin: %s", pluginContainer.getMetaInformation().getName().c_str());
-        if (!PluginManagement::doRelocation(pluginContainer.getPluginInformation().getRelocationDataList(),
+        if (!PluginManagement::doRelocation(pluginContainer.getPluginLinkInformation()->getRelocationDataList(),
                                             trampData,
-                                            pluginContainer.getPluginInformation().getTrampolineId(),
+                                            pluginContainer.getPluginLinkInformation()->getTrampolineId(),
                                             usedRPls)) {
             return false;
         }
@@ -153,7 +156,10 @@ bool PluginManagement::doRelocations(const std::vector<PluginContainer> &plugins
 
 bool PluginManagement::RestoreFunctionPatches(std::vector<PluginContainer> &plugins) {
     for (auto &cur : std::ranges::reverse_view(plugins)) {
-        for (auto &curFunction : std::ranges::reverse_view(cur.getPluginInformation().getFunctionDataList())) {
+        if (!cur.isPluginLinkedAndLoaded()) {
+            continue;
+        }
+        for (auto &curFunction : std::ranges::reverse_view(cur.getPluginLinkInformation()->getFunctionDataList())) {
             if (!curFunction.RemovePatch()) {
                 return false;
             }
@@ -164,7 +170,10 @@ bool PluginManagement::RestoreFunctionPatches(std::vector<PluginContainer> &plug
 
 bool PluginManagement::DoFunctionPatches(std::vector<PluginContainer> &plugins) {
     for (auto &cur : plugins) {
-        for (auto &curFunction : cur.getPluginInformation().getFunctionDataList()) {
+        if (!cur.isPluginLinkedAndLoaded()) {
+            continue;
+        }
+        for (auto &curFunction : cur.getPluginLinkInformation()->getFunctionDataList()) {
             if (!curFunction.AddPatch()) {
                 DEBUG_FUNCTION_LINE_ERR("Failed to add function patch for: plugin %s", cur.getMetaInformation().getName().c_str());
                 return false;

source/hooks.cpp

@@ -38,12 +38,18 @@ static const char **hook_names = (const char *[]){
 void CallHook(const std::vector<PluginContainer> &plugins, wups_loader_hook_type_t hook_type) {
     DEBUG_FUNCTION_LINE_VERBOSE("Calling hook of type %s [%d]", hook_names[hook_type], hook_type);
     for (const auto &plugin : plugins) {
+        if (!plugin.isPluginLinkedAndLoaded()) {
+            return;
+        }
         CallHook(plugin, hook_type);
     }
 }
 
 void CallHook(const PluginContainer &plugin, wups_loader_hook_type_t hook_type) {
-    for (const auto &hook : plugin.getPluginInformation().getHookDataList()) {
+    if (!plugin.isPluginLinkedAndLoaded()) {
+        return;
+    }
+    for (const auto &hook : plugin.getPluginLinkInformation()->getHookDataList()) {
         if (hook.getType() == hook_type) {
             DEBUG_FUNCTION_LINE_VERBOSE("Calling hook of type %s for plugin %s [%d]", hook_names[hook.getType()], plugin.getMetaInformation().getName().c_str(), hook_type);
             void *func_ptr = hook.getFunctionPointer();

source/main.cpp

@@ -5,6 +5,7 @@
 #include "hooks.h"
 #include "patcher/hooks_patcher_static.h"
 #include "plugin/PluginDataFactory.h"
+#include "plugin/PluginMetaInformationFactory.h"
 #include "utils/utils.h"
 #include <coreinit/debug.h>
 #include <notifications/notifications.h>
@@ -190,7 +191,10 @@ WUMS_APPLICATION_STARTS() {
 void CheckCleanupCallbackUsage(const std::vector<PluginContainer> &plugins) {
     auto *curThread = OSGetCurrentThread();
     for (const auto &cur : plugins) {
-        auto textSection = cur.getPluginInformation().getSectionInfo(".text");
+        if (!cur.isPluginLinkedAndLoaded()) {
+            continue;
+        }
+        auto textSection = cur.getPluginLinkInformation()->getSectionInfo(".text");
         if (!textSection) {
             continue;
         }

source/patcher/hooks_patcher_static.cpp

@@ -146,7 +146,10 @@ DECL_FUNCTION(uint32_t, SC17_FindClosestSymbol,
               char *moduleNameBuffer,
               uint32_t moduleNameBufferLength) {
     for (const auto &plugin : gLoadedPlugins) {
-        const auto sectionInfo = plugin.getPluginInformation().getSectionInfo(".text");
+        if (!plugin.isPluginLinkedAndLoaded()) {
+            continue;
+        }
+        const auto sectionInfo = plugin.getPluginLinkInformation()->getSectionInfo(".text");
         if (!sectionInfo) {
             continue;
         }
@@ -156,7 +159,7 @@ DECL_FUNCTION(uint32_t, SC17_FindClosestSymbol,
         }
 
         strncpy(moduleNameBuffer, plugin.getMetaInformation().getName().c_str(), moduleNameBufferLength - 1);
-        auto functionSymbolData = plugin.getPluginInformation().getNearestFunctionSymbolData(addr);
+        auto functionSymbolData = plugin.getPluginLinkInformation()->getNearestFunctionSymbolData(addr);
         if (functionSymbolData) {
             strncpy(symbolNameBuffer, functionSymbolData->getName().c_str(), moduleNameBufferLength - 1);
             if (outDistance) {
@@ -179,7 +182,10 @@ DECL_FUNCTION(uint32_t, SC17_FindClosestSymbol,
 
 DECL_FUNCTION(uint32_t, KiGetAppSymbolName, uint32_t addr, char *buffer, int32_t bufSize) {
     for (const auto &plugin : gLoadedPlugins) {
-        const auto sectionInfo = plugin.getPluginInformation().getSectionInfo(".text");
+        if (!plugin.isPluginLinkedAndLoaded()) {
+            continue;
+        }
+        const auto sectionInfo = plugin.getPluginLinkInformation()->getSectionInfo(".text");
         if (!sectionInfo) {
             continue;
         }
@@ -195,7 +201,7 @@ DECL_FUNCTION(uint32_t, KiGetAppSymbolName, uint32_t addr, char *buffer, int32_t
         }
         strncpy(buffer, plugin.getMetaInformation().getName().c_str(), bufSize - 1);
 
-        const auto functionSymbolData = plugin.getPluginInformation().getNearestFunctionSymbolData(addr);
+        const auto functionSymbolData = plugin.getPluginLinkInformation()->getNearestFunctionSymbolData(addr);
         if (functionSymbolData) {
             buffer[pluginNameLen]     = '|';
             buffer[pluginNameLen + 1] = '\0';

source/plugin/PluginContainer.cpp

@@ -1,13 +1,13 @@
 #include "PluginContainer.h"
 
-PluginContainer::PluginContainer(PluginMetaInformation metaInformation, PluginInformation pluginInformation, std::shared_ptr<PluginData> pluginData)
+PluginContainer::PluginContainer(PluginMetaInformation metaInformation, std::optional<PluginLinkInformation> pluginLinkInformation, std::shared_ptr<PluginData> pluginData)
     : mMetaInformation(std::move(metaInformation)),
-      mPluginInformation(std::move(pluginInformation)),
+      mPluginLinkInformation(std::move(pluginLinkInformation)),
       mPluginData(std::move(pluginData)) {
 }
 
 PluginContainer::PluginContainer(PluginContainer &&src) : mMetaInformation(std::move(src.mMetaInformation)),
-                                                          mPluginInformation(std::move(src.mPluginInformation)),
+                                                          mPluginLinkInformation(std::move(src.mPluginLinkInformation)),
                                                           mPluginData(std::move(src.mPluginData)),
                                                           mPluginConfigData(std::move(src.mPluginConfigData)),
                                                           storageRootItem(src.storageRootItem)
@@ -19,7 +19,7 @@ PluginContainer::PluginContainer(PluginContainer &&src) : mMetaInformation(std::
 PluginContainer &PluginContainer::operator=(PluginContainer &&src) {
     if (this != &src) {
         this->mMetaInformation       = src.mMetaInformation;
-        this->mPluginInformation = std::move(src.mPluginInformation);
+        this->mPluginLinkInformation = std::move(src.mPluginLinkInformation);
         this->mPluginData            = std::move(src.mPluginData);
         this->mPluginConfigData      = std::move(src.mPluginConfigData);
         this->storageRootItem        = src.storageRootItem;
@@ -33,12 +33,22 @@ const PluginMetaInformation &PluginContainer::getMetaInformation() const {
     return this->mMetaInformation;
 }
 
-const PluginInformation &PluginContainer::getPluginInformation() const {
+bool PluginContainer::isPluginLinkedAndLoaded() const {
-    return this->mPluginInformation;
+    return this->mPluginLinkInformation.has_value();
 }
 
-PluginInformation &PluginContainer::getPluginInformation() {
+const PluginLinkInformation *PluginContainer::getPluginLinkInformation() const {
-    return this->mPluginInformation;
+    if (this->mPluginLinkInformation.has_value()) {
+        return this->mPluginLinkInformation.operator->();
+    }
+    return nullptr;
+}
+
+PluginLinkInformation *PluginContainer::getPluginLinkInformation() {
+    if (this->mPluginLinkInformation.has_value()) {
+        return this->mPluginLinkInformation.operator->();
+    }
+    return nullptr;
 }
 
 std::shared_ptr<PluginData> PluginContainer::getPluginDataCopy() const {

source/plugin/PluginContainer.h

@@ -19,7 +19,7 @@
 
 #include "PluginConfigData.h"
 #include "PluginData.h"
-#include "PluginInformation.h"
+#include "PluginLinkInformation.h"
 #include "PluginMetaInformation.h"
 #include "utils/storage/StorageUtils.h"
 #include <memory>
@@ -28,24 +28,24 @@
 
 class PluginContainer {
 public:
-    PluginContainer(PluginMetaInformation metaInformation, PluginInformation pluginInformation, std::shared_ptr<PluginData> pluginData);
+    PluginContainer(PluginMetaInformation metaInformation, std::optional<PluginLinkInformation> pluginLinkInformation, std::shared_ptr<PluginData> pluginData);
-
 
     PluginContainer(const PluginContainer &) = delete;
 
-
     PluginContainer(PluginContainer &&src);
 
     PluginContainer &operator=(PluginContainer &&src);
 
-
     [[nodiscard]] const PluginMetaInformation &getMetaInformation() const;
 
-    [[nodiscard]] const PluginInformation &getPluginInformation() const;
+    [[nodiscard]] const PluginLinkInformation *getPluginLinkInformation() const;
-    [[nodiscard]] PluginInformation &getPluginInformation();
+
+    [[nodiscard]] PluginLinkInformation *getPluginLinkInformation();
 
     [[nodiscard]] std::shared_ptr<PluginData> getPluginDataCopy() const;
 
+    [[nodiscard]] bool isPluginLinkedAndLoaded() const;
+
     [[nodiscard]] uint32_t getHandle() const;
 
     [[nodiscard]] const std::optional<PluginConfigData> &getConfigData() const;
@@ -62,7 +62,7 @@ public:
 
 private:
     PluginMetaInformation mMetaInformation;
-    PluginInformation mPluginInformation;
+    std::optional<PluginLinkInformation> mPluginLinkInformation;
     std::shared_ptr<PluginData> mPluginData;
 
     std::optional<PluginConfigData> mPluginConfigData;

source/plugin/PluginLinkInformation.cpp

@@ -1,6 +1,6 @@
-#include "PluginInformation.h"
+#include "PluginLinkInformation.h"
 
-PluginInformation::PluginInformation(PluginInformation &&src) : mHookDataList(std::move(src.mHookDataList)),
+PluginLinkInformation::PluginLinkInformation(PluginLinkInformation &&src) : mHookDataList(std::move(src.mHookDataList)),
                                                                             mFunctionDataList(std::move(src.mFunctionDataList)),
                                                                             mRelocationDataList(std::move(src.mRelocationDataList)),
                                                                             mSymbolDataList(std::move(src.mSymbolDataList)),
@@ -13,7 +13,7 @@ PluginInformation::PluginInformation(PluginInformation &&src) : mHookDataList(st
     src.mTrampolineId = {};
 }
 
-PluginInformation &PluginInformation::operator=(PluginInformation &&src) {
+PluginLinkInformation &PluginLinkInformation::operator=(PluginLinkInformation &&src) {
     if (this != &src) {
         this->mHookDataList               = std::move(src.mHookDataList);
         this->mFunctionDataList           = std::move(src.mFunctionDataList);
@@ -28,62 +28,62 @@ PluginInformation &PluginInformation::operator=(PluginInformation &&src) {
     return *this;
 }
 
-void PluginInformation::addHookData(HookData hook_data) {
+void PluginLinkInformation::addHookData(HookData hook_data) {
     mHookDataList.push_back(hook_data);
 }
 
-const std::vector<HookData> &PluginInformation::getHookDataList() const {
+const std::vector<HookData> &PluginLinkInformation::getHookDataList() const {
     return mHookDataList;
 }
 
-void PluginInformation::addFunctionData(FunctionData function_data) {
+void PluginLinkInformation::addFunctionData(FunctionData function_data) {
     mFunctionDataList.push_back(std::move(function_data));
 }
 
-const std::vector<FunctionData> &PluginInformation::getFunctionDataList() const {
+const std::vector<FunctionData> &PluginLinkInformation::getFunctionDataList() const {
     return mFunctionDataList;
 }
 
-std::vector<FunctionData> &PluginInformation::getFunctionDataList() {
+std::vector<FunctionData> &PluginLinkInformation::getFunctionDataList() {
     return mFunctionDataList;
 }
 
-void PluginInformation::addRelocationData(RelocationData relocation_data) {
+void PluginLinkInformation::addRelocationData(RelocationData relocation_data) {
     mRelocationDataList.push_back(std::move(relocation_data));
 }
 
-const std::vector<RelocationData> &PluginInformation::getRelocationDataList() const {
+const std::vector<RelocationData> &PluginLinkInformation::getRelocationDataList() const {
     return mRelocationDataList;
 }
 
-void PluginInformation::addFunctionSymbolData(const FunctionSymbolData &symbol_data) {
+void PluginLinkInformation::addFunctionSymbolData(const FunctionSymbolData &symbol_data) {
     mSymbolDataList.insert(symbol_data);
 }
 
-void PluginInformation::addSectionInfo(const SectionInfo &sectionInfo) {
+void PluginLinkInformation::addSectionInfo(const SectionInfo &sectionInfo) {
     mSectionInfoList.insert(std::pair(sectionInfo.getName(), sectionInfo));
 }
 
-const std::map<std::string, SectionInfo> &PluginInformation::getSectionInfoList() const {
+const std::map<std::string, SectionInfo> &PluginLinkInformation::getSectionInfoList() const {
     return mSectionInfoList;
 }
 
-std::optional<SectionInfo> PluginInformation::getSectionInfo(const std::string &sectionName) const {
+std::optional<SectionInfo> PluginLinkInformation::getSectionInfo(const std::string &sectionName) const {
     if (getSectionInfoList().contains(sectionName)) {
         return mSectionInfoList.at(sectionName);
     }
     return std::nullopt;
 }
 
-void PluginInformation::setTrampolineId(uint8_t trampolineId) {
+void PluginLinkInformation::setTrampolineId(uint8_t trampolineId) {
     this->mTrampolineId = trampolineId;
 }
 
-uint8_t PluginInformation::getTrampolineId() const {
+uint8_t PluginLinkInformation::getTrampolineId() const {
     return mTrampolineId;
 }
 
-const FunctionSymbolData *PluginInformation::getNearestFunctionSymbolData(uint32_t address) const {
+const FunctionSymbolData *PluginLinkInformation::getNearestFunctionSymbolData(uint32_t address) const {
     const FunctionSymbolData *result = nullptr;
 
     bool foundHit = false;
@@ -103,10 +103,10 @@ const FunctionSymbolData *PluginInformation::getNearestFunctionSymbolData(uint32
     return result;
 }
 
-const HeapMemoryFixedSize &PluginInformation::getTextMemory() const {
+const HeapMemoryFixedSize &PluginLinkInformation::getTextMemory() const {
     return mAllocatedTextMemoryAddress;
 }
 
-const HeapMemoryFixedSize &PluginInformation::getDataMemory() const {
+const HeapMemoryFixedSize &PluginLinkInformation::getDataMemory() const {
     return mAllocatedDataMemoryAddress;
 }

source/plugin/PluginLinkInformation.h

@@ -40,13 +40,13 @@ struct FunctionSymbolDataComparator {
     }
 };
 
-class PluginInformation {
+class PluginLinkInformation {
 public:
-    PluginInformation(const PluginInformation &) = delete;
+    PluginLinkInformation(const PluginLinkInformation &) = delete;
 
-    PluginInformation(PluginInformation &&src);
+    PluginLinkInformation(PluginLinkInformation &&src);
 
-    PluginInformation &operator=(PluginInformation &&src);
+    PluginLinkInformation &operator=(PluginLinkInformation &&src);
 
     [[nodiscard]] const std::vector<HookData> &getHookDataList() const;
 
@@ -69,7 +69,7 @@ public:
     [[nodiscard]] const HeapMemoryFixedSize &getDataMemory() const;
 
 private:
-    PluginInformation() = default;
+    PluginLinkInformation() = default;
 
     void addHookData(HookData hook_data);
 
@@ -94,5 +94,5 @@ private:
     HeapMemoryFixedSize mAllocatedTextMemoryAddress;
     HeapMemoryFixedSize mAllocatedDataMemoryAddress;
 
-    friend class PluginInformationFactory;
+    friend class PluginLinkInformationFactory;
 };

source/plugin/PluginLinkInformationFactory.cpp

@@ -15,7 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
 
-#include "PluginInformationFactory.h"
+#include "PluginLinkInformationFactory.h"
 #include "../utils/ElfUtils.h"
 #include "utils/HeapMemoryFixedSize.h"
 #include "utils/wiiu_zlib.hpp"
@@ -27,8 +27,8 @@
 
 using namespace ELFIO;
 
-std::optional<PluginInformation>
+std::optional<PluginLinkInformation>
-PluginInformationFactory::load(const PluginData &pluginData, std::vector<relocation_trampoline_entry_t> &trampolineData, uint8_t trampolineId) {
+PluginLinkInformationFactory::load(const PluginData &pluginData, std::vector<relocation_trampoline_entry_t> &trampolineData, uint8_t trampolineId) {
     auto buffer = pluginData.getBuffer();
     if (buffer.empty()) {
         DEBUG_FUNCTION_LINE_ERR("Buffer was empty");
@@ -41,7 +41,7 @@ PluginInformationFactory::load(const PluginData &pluginData, std::vector<relocat
         return std::nullopt;
     }
 
-    PluginInformation pluginInfo;
+    PluginLinkInformation pluginInfo;
 
     uint32_t sec_num = reader.sections.size();
 
@@ -169,7 +169,7 @@ PluginInformationFactory::load(const PluginData &pluginData, std::vector<relocat
         }
     }
 
-    if (!PluginInformationFactory::addImportRelocationData(pluginInfo, reader, destinations)) {
+    if (!PluginLinkInformationFactory::addImportRelocationData(pluginInfo, reader, destinations)) {
         DEBUG_FUNCTION_LINE_ERR("addImportRelocationData failed");
         return std::nullopt;
     }
@@ -265,7 +265,7 @@ PluginInformationFactory::load(const PluginData &pluginData, std::vector<relocat
     return pluginInfo;
 }
 
-bool PluginInformationFactory::addImportRelocationData(PluginInformation &pluginInfo, const elfio &reader, std::span<uint8_t *> destinations) {
+bool PluginLinkInformationFactory::addImportRelocationData(PluginLinkInformation &pluginInfo, const elfio &reader, std::span<uint8_t *> destinations) {
     std::map<uint32_t, std::shared_ptr<ImportRPLInformation>> infoMap;
 
     uint32_t sec_num = reader.sections.size();
@@ -336,7 +336,7 @@ bool PluginInformationFactory::addImportRelocationData(PluginInformation &plugin
     return true;
 }
 
-bool PluginInformationFactory::linkSection(const elfio &reader, uint32_t section_index, uint32_t destination, uint32_t base_text, uint32_t base_data,
+bool PluginLinkInformationFactory::linkSection(const elfio &reader, uint32_t section_index, uint32_t destination, uint32_t base_text, uint32_t base_data,
                                            std::vector<relocation_trampoline_entry_t> &trampolineData, uint8_t trampolineId) {
     uint32_t sec_num = reader.sections.size();
 

source/plugin/PluginLinkInformationFactory.h

@@ -19,7 +19,7 @@
 
 #include "../elfio/elfio.hpp"
 #include "PluginContainer.h"
-#include "PluginInformation.h"
+#include "PluginLinkInformation.h"
 #include <coreinit/memheap.h>
 #include <map>
 #include <optional>
@@ -27,15 +27,16 @@
 #include <vector>
 #include <wums/defines/relocation_defines.h>
 
-class PluginInformationFactory {
+class PluginLinkInformationFactory {
 public:
-    static std::optional<PluginInformation>
+    static std::optional<PluginLinkInformation>
     load(const PluginData &pluginData, std::vector<relocation_trampoline_entry_t> &trampolineData, uint8_t trampolineId);
 
+private:
     static bool
     linkSection(const ELFIO::elfio &reader, uint32_t section_index, uint32_t destination, uint32_t base_text, uint32_t base_data,
                 std::vector<relocation_trampoline_entry_t> &trampolineData, uint8_t trampolineId);
 
     static bool
-    addImportRelocationData(PluginInformation &pluginInfo, const ELFIO::elfio &reader, std::span<uint8_t *> destinations);
+    addImportRelocationData(PluginLinkInformation &pluginInfo, const ELFIO::elfio &reader, std::span<uint8_t *> destinations);
 };

source/utils/config/ConfigUtils.cpp

@@ -76,6 +76,9 @@ void ConfigUtils::displayMenu() {
 
     std::vector<ConfigDisplayItem> configs;
     for (const auto &plugin : gLoadedPlugins) {
+        if (!plugin.isPluginLinkedAndLoaded()) {
+            continue;
+        }
         GeneralConfigInformation info;
         info.name    = plugin.getMetaInformation().getName();
         info.author  = plugin.getMetaInformation().getAuthor();
@@ -100,7 +103,7 @@ void ConfigUtils::displayMenu() {
                 DEBUG_FUNCTION_LINE_ERR("Failed to create config for plugin: \"%s\"", info.name.c_str());
             }
         } else {
-            for (const auto &hook : plugin.getPluginInformation().getHookDataList()) {
+            for (const auto &hook : plugin.getPluginLinkInformation()->getHookDataList()) {
                 if (hook.getType() == WUPS_LOADER_HOOK_GET_CONFIG_DEPRECATED) {
                     if (hook.getFunctionPointer() == nullptr) {
                         DEBUG_FUNCTION_LINE_ERR("Hook had invalid ptr");

source/utils/exports.cpp

@@ -272,9 +272,9 @@ extern "C" PluginBackendApiErrorType WUPSGetSectionInformationForPlugin(const wu
     if (handle != 0 && plugin_section_list != nullptr && buffer_size != 0) {
         bool found = false;
         for (const auto &curContainer : gLoadedPlugins) {
-            if (curContainer.getHandle() == handle) {
+            if (curContainer.isPluginLinkedAndLoaded() && curContainer.getHandle() == handle) {
                 found                       = true;
-                const auto &sectionInfoList = curContainer.getPluginInformation().getSectionInfoList();
+                const auto &sectionInfoList = curContainer.getPluginLinkInformation()->getSectionInfoList();
 
                 uint32_t offset = 0;
                 for (auto const &[key, sectionInfo] : sectionInfoList) {
@@ -316,9 +316,9 @@ extern "C" PluginBackendApiErrorType WUPSGetSectionMemoryAddresses(wups_backend_
         return PLUGIN_BACKEND_API_ERROR_INVALID_ARG;
     }
     for (const auto &curContainer : gLoadedPlugins) {
-        if (curContainer.getHandle() == handle) {
+        if (curContainer.isPluginLinkedAndLoaded() && curContainer.getHandle() == handle) {
-            *textAddress = (void *) curContainer.getPluginInformation().getTextMemory().data();
+            *textAddress = (void *) curContainer.getPluginLinkInformation()->getTextMemory().data();
-            *dataAddress = (void *) curContainer.getPluginInformation().getDataMemory().data();
+            *dataAddress = (void *) curContainer.getPluginLinkInformation()->getDataMemory().data();
             return PLUGIN_BACKEND_API_ERROR_NONE;
         }
     }