fix(pluginmanager): Invalid paths

skuzzis · skuzzis · commit d6cfe0577009 · 2024-08-16T09:34:26.000Z
diff --git a/src/entrypoint.cpp b/src/entrypoint.cpp
@@ -92,6 +92,7 @@ CGameEntitySystem* GameEntitySystem()
 CUtlVector<FuncHookBase*> g_vecHooks;
 std::map<std::string, PluginUserMessage> scriptingUserMessages;
 std::map<std::string, FakeConVar*> fakeConvars;
+std::map<std::string, std::string> pluginBasePaths;
 
 Addons g_addons;
 CommandsManager* g_commandsManager = nullptr;
diff --git a/src/plugins/Plugin.h b/src/plugins/Plugin.h
@@ -3,6 +3,7 @@
 
 #include <string>
 #include <vector>
+#include <map>
 #include "../types/PluginKind.h"
 #include "../types/PluginState.h"
 #include "../types/EventResult.h"
@@ -35,17 +36,19 @@ class Plugin
     virtual bool ExecuteStart() = 0;
     virtual void ExecuteStop() = 0;
 
-    virtual void ExecuteCommand(void *functionPtr, std::string name, int slot, std::vector<std::string> args, bool silent, std::string prefix) = 0;
+    virtual void ExecuteCommand(void* functionPtr, std::string name, int slot, std::vector<std::string> args, bool silent, std::string prefix) = 0;
 
-    virtual void RegisterEventHandler(void *functionPtr) = 0;
+    virtual void RegisterEventHandler(void* functionPtr) = 0;
     virtual void RegisterEventHandling(std::string eventName) = 0;
 
     virtual std::string GetAuthor() = 0;
     virtual std::string GetWebsite() = 0;
     virtual std::string GetVersion() = 0;
     virtual std::string GetPlName() = 0;
 
-    virtual EventResult TriggerEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent *event) = 0;
+    virtual EventResult TriggerEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent* event) = 0;
 };
 
+extern std::map<std::string, std::string> pluginBasePaths;
+
 #endif
diff --git a/src/plugins/PluginManager.cpp b/src/plugins/PluginManager.cpp
@@ -19,10 +19,11 @@ bool PluginManager::PluginExists(std::string plugin_name)
 
 void PluginManager::LoadPlugins(std::string directory)
 {
-    if (!Files::ExistsPath("addons/swiftly/plugins" + directory))
-        Files::CreateDirectory("addons/swiftly/plugins" + directory);
+    std::string baseDir = "addons/swiftly/plugins" + directory;
+    if (!Files::ExistsPath(baseDir))
+        Files::CreateDirectory(baseDir);
 
-    std::vector<std::string> plugins = Files::FetchDirectories("addons/swiftly/plugins" + directory);
+    std::vector<std::string> plugins = Files::FetchDirectories(baseDir);
     for (std::string folder : plugins)
     {
         // Skips over disabled
@@ -35,18 +36,20 @@ void PluginManager::LoadPlugins(std::string directory)
             LoadPlugins(directory + "/" + directory_name);
         else
         {
-            folder = replace(folder, "addons/swiftly/plugins" + directory, "");
+            folder = replace(folder, baseDir, "");
             std::string plugin_name = replace(folder, WIN_LINUX("\\", "/"), "");
 
-            LoadPlugin(plugin_name);            
+            pluginBasePaths[plugin_name] = baseDir;
+
+            LoadPlugin(plugin_name);
         }
     }
 }
 
 void PluginManager::UnloadPlugins()
 {
     std::vector<std::string> pluginNames;
-    for (Plugin *plugin : pluginsList)
+    for (Plugin* plugin : pluginsList)
         pluginNames.push_back(plugin->GetName());
 
     for (std::string plugin_name : pluginNames)
@@ -58,11 +61,11 @@ void PluginManager::LoadPlugin(std::string plugin_name)
     if (PluginExists(plugin_name))
         return;
 
-    std::vector<std::string> files = Files::FetchFileNames("addons/swiftly/plugins/" + plugin_name);
+    std::vector<std::string> files = Files::FetchFileNames(pluginBasePaths[plugin_name] + "/" + plugin_name);
     if (files.size() == 0)
         return;
 
-    Plugin *plugin = nullptr;
+    Plugin* plugin = nullptr;
 
     for (std::string file : files)
     {
@@ -80,15 +83,15 @@ void PluginManager::LoadPlugin(std::string plugin_name)
     }
 
     pluginsList.push_back(plugin);
-    pluginsMap.insert({plugin_name, plugin});
+    pluginsMap.insert({ plugin_name, plugin });
 }
 
 void PluginManager::UnloadPlugin(std::string plugin_name)
 {
     if (!PluginExists(plugin_name))
         return;
 
-    Plugin *plugin = pluginsMap.at(plugin_name);
+    Plugin* plugin = pluginsMap.at(plugin_name);
 
     auto it = std::find(pluginsList.begin(), pluginsList.end(), plugin);
     if (it != pluginsList.end())
@@ -100,7 +103,7 @@ void PluginManager::UnloadPlugin(std::string plugin_name)
 
 void PluginManager::StartPlugins()
 {
-    for (Plugin *plugin : pluginsList)
+    for (Plugin* plugin : pluginsList)
         if (!StartPlugin(plugin->GetName()))
             StopPlugin(plugin->GetName());
 
@@ -109,15 +112,15 @@ void PluginManager::StartPlugins()
 
     msgpack::pack(ss, eventData);
 
-    PluginEvent *event = new PluginEvent("core", nullptr, nullptr);
+    PluginEvent* event = new PluginEvent("core", nullptr, nullptr);
     this->ExecuteEvent("core", "OnAllPluginsLoaded", ss.str(), event);
     delete event;
     AllPluginsStarted = true;
 }
 
 void PluginManager::StopPlugins()
 {
-    for (Plugin *plugin : pluginsList)
+    for (Plugin* plugin : pluginsList)
         StopPlugin(plugin->GetName());
 }
 
@@ -126,7 +129,7 @@ bool PluginManager::StartPlugin(std::string plugin_name)
     if (!PluginExists(plugin_name))
         return false;
 
-    Plugin *plugin = pluginsMap.at(plugin_name);
+    Plugin* plugin = pluginsMap.at(plugin_name);
     if (plugin->GetPluginState() == PluginState_t::Started)
         return true;
 
@@ -143,7 +146,7 @@ bool PluginManager::StartPlugin(std::string plugin_name)
 
         msgpack::pack(ss, eventData);
 
-        PluginEvent *event = new PluginEvent("core", nullptr, nullptr);
+        PluginEvent* event = new PluginEvent("core", nullptr, nullptr);
         plugin->TriggerEvent("core", "OnAllPluginsLoaded", ss.str(), event);
         delete event;
     }
@@ -156,7 +159,7 @@ void PluginManager::StopPlugin(std::string plugin_name)
     if (!PluginExists(plugin_name))
         return;
 
-    Plugin *plugin = pluginsMap.at(plugin_name);
+    Plugin* plugin = pluginsMap.at(plugin_name);
     if (plugin->GetPluginState() == PluginState_t::Stopped)
         return;
 
@@ -167,17 +170,17 @@ void PluginManager::StopPlugin(std::string plugin_name)
     g_MenuManager->UnregisterPluginMenus(plugin_name);
 }
 
-Plugin *PluginManager::FetchPlugin(std::string name)
+Plugin* PluginManager::FetchPlugin(std::string name)
 {
     if (!PluginExists(name))
         return nullptr;
 
     return pluginsMap.at(name);
 }
 
-EventResult PluginManager::ExecuteEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent *event)
+EventResult PluginManager::ExecuteEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent* event)
 {
-    for (Plugin *plugin : this->pluginsList)
+    for (Plugin* plugin : this->pluginsList)
     {
         EventResult result = plugin->TriggerEvent(invokedBy, eventName, eventPayload, event);
         if (result != EventResult::Continue)
@@ -187,7 +190,7 @@ EventResult PluginManager::ExecuteEvent(std::string invokedBy, std::string event
     return EventResult::Continue;
 }
 
-std::vector<Plugin *> PluginManager::GetPluginsList()
+std::vector<Plugin*> PluginManager::GetPluginsList()
 {
     return this->pluginsList;
 }
diff --git a/src/plugins/PluginManager.h b/src/plugins/PluginManager.h
@@ -15,8 +15,8 @@ class PluginEvent;
 class PluginManager
 {
 private:
-    std::vector<Plugin *> pluginsList;
-    std::map<std::string, Plugin *> pluginsMap;
+    std::vector<Plugin*> pluginsList;
+    std::map<std::string, Plugin*> pluginsMap;
 
 public:
     PluginManager();
@@ -36,13 +36,14 @@ class PluginManager
     bool StartPlugin(std::string plugin_name);
     void StopPlugin(std::string plugin_name);
 
-    Plugin *FetchPlugin(std::string name);
+    Plugin* FetchPlugin(std::string name);
 
-    std::vector<Plugin *> GetPluginsList();
+    std::vector<Plugin*> GetPluginsList();
 
-    EventResult ExecuteEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent *event);
+    EventResult ExecuteEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent* event);
 };
 
-extern PluginManager *g_pluginManager;
+extern PluginManager* g_pluginManager;
+extern std::map<std::string, std::string> pluginBasePaths;
 
 #endif
diff --git a/src/plugins/core/scripting/utils.cpp b/src/plugins/core/scripting/utils.cpp
@@ -41,7 +41,7 @@ std::string scripting_GetPluginPath(std::string plugin_name)
     Plugin* plugin = g_pluginManager->FetchPlugin(plugin_name);
     if (!plugin) return "";
 
-    return string_format("addons/swiftly/plugins/%s", plugin->GetName().c_str());
+    return string_format("%s/%s", pluginBasePaths[plugin_name].c_str(), plugin->GetName().c_str());
 }
 
 PluginUserMessage scripting_GetUserMessage(std::string uuid)
diff --git a/src/plugins/lua/LuaPlugin.cpp b/src/plugins/lua/LuaPlugin.cpp
@@ -102,7 +102,7 @@ bool LuaPlugin::LoadScriptingEnvironment()
 
     luabridge::setGlobal(this->state, NULL, "AddGlobalEvents");
 
-    std::vector<std::string> files = Files::FetchFileNames("addons/swiftly/plugins/" + this->GetName());
+    std::vector<std::string> files = Files::FetchFileNames(pluginBasePaths[this->GetName()] + "/" + this->GetName());
     for (std::string file : files)
     {
         if (ends_with(file, ".lua"))

Original file line number	Diff line number	Diff line change
`@@ -19,10 +19,11 @@ bool PluginManager::PluginExists(std::string plugin_name)`
`19`	`19`
`20`	`20`	`void PluginManager::LoadPlugins(std::string directory)`
`21`	`21`	`{`
`22`		`- if (!Files::ExistsPath("addons/swiftly/plugins" + directory))`
`23`		`- Files::CreateDirectory("addons/swiftly/plugins" + directory);`
	`22`	`+ std::string baseDir = "addons/swiftly/plugins" + directory;`
	`23`	`+ if (!Files::ExistsPath(baseDir))`
	`24`	`+ Files::CreateDirectory(baseDir);`
`24`	`25`
`25`		`- std::vector<std::string> plugins = Files::FetchDirectories("addons/swiftly/plugins" + directory);`
	`26`	`+ std::vector<std::string> plugins = Files::FetchDirectories(baseDir);`
`26`	`27`	`for (std::string folder : plugins)`
`27`	`28`	`{`
`28`	`29`	`// Skips over disabled`
`@@ -35,18 +36,20 @@ void PluginManager::LoadPlugins(std::string directory)`
`35`	`36`	`LoadPlugins(directory + "/" + directory_name);`
`36`	`37`	`else`
`37`	`38`	`{`
`38`		`- folder = replace(folder, "addons/swiftly/plugins" + directory, "");`
	`39`	`+ folder = replace(folder, baseDir, "");`
`39`	`40`	`std::string plugin_name = replace(folder, WIN_LINUX("\\", "/"), "");`
`40`	`41`
`41`		`- LoadPlugin(plugin_name);`
	`42`	`+ pluginBasePaths[plugin_name] = baseDir;`
	`43`	`+`
	`44`	`+ LoadPlugin(plugin_name);`
`42`	`45`	`}`
`43`	`46`	`}`
`44`	`47`	`}`
`45`	`48`
`46`	`49`	`void PluginManager::UnloadPlugins()`
`47`	`50`	`{`
`48`	`51`	`std::vector<std::string> pluginNames;`
`49`		`- for (Plugin *plugin : pluginsList)`
	`52`	`+ for (Plugin* plugin : pluginsList)`
`50`	`53`	`pluginNames.push_back(plugin->GetName());`
`51`	`54`
`52`	`55`	`for (std::string plugin_name : pluginNames)`
`@@ -58,11 +61,11 @@ void PluginManager::LoadPlugin(std::string plugin_name)`
`58`	`61`	`if (PluginExists(plugin_name))`
`59`	`62`	`return;`
`60`	`63`
`61`		`- std::vector<std::string> files = Files::FetchFileNames("addons/swiftly/plugins/" + plugin_name);`
	`64`	`+ std::vector<std::string> files = Files::FetchFileNames(pluginBasePaths[plugin_name] + "/" + plugin_name);`
`62`	`65`	`if (files.size() == 0)`
`63`	`66`	`return;`
`64`	`67`
`65`		`- Plugin *plugin = nullptr;`
	`68`	`+ Plugin* plugin = nullptr;`
`66`	`69`
`67`	`70`	`for (std::string file : files)`
`68`	`71`	`{`
`@@ -80,15 +83,15 @@ void PluginManager::LoadPlugin(std::string plugin_name)`
`80`	`83`	`}`
`81`	`84`
`82`	`85`	`pluginsList.push_back(plugin);`
`83`		`- pluginsMap.insert({plugin_name, plugin});`
	`86`	`+ pluginsMap.insert({ plugin_name, plugin });`
`84`	`87`	`}`
`85`	`88`
`86`	`89`	`void PluginManager::UnloadPlugin(std::string plugin_name)`
`87`	`90`	`{`
`88`	`91`	`if (!PluginExists(plugin_name))`
`89`	`92`	`return;`
`90`	`93`
`91`		`- Plugin *plugin = pluginsMap.at(plugin_name);`
	`94`	`+ Plugin* plugin = pluginsMap.at(plugin_name);`
`92`	`95`
`93`	`96`	`auto it = std::find(pluginsList.begin(), pluginsList.end(), plugin);`
`94`	`97`	`if (it != pluginsList.end())`
`@@ -100,7 +103,7 @@ void PluginManager::UnloadPlugin(std::string plugin_name)`
`100`	`103`
`101`	`104`	`void PluginManager::StartPlugins()`
`102`	`105`	`{`
`103`		`- for (Plugin *plugin : pluginsList)`
	`106`	`+ for (Plugin* plugin : pluginsList)`
`104`	`107`	`if (!StartPlugin(plugin->GetName()))`
`105`	`108`	`StopPlugin(plugin->GetName());`
`106`	`109`
`@@ -109,15 +112,15 @@ void PluginManager::StartPlugins()`
`109`	`112`
`110`	`113`	`msgpack::pack(ss, eventData);`
`111`	`114`
`112`		`- PluginEvent *event = new PluginEvent("core", nullptr, nullptr);`
	`115`	`+ PluginEvent* event = new PluginEvent("core", nullptr, nullptr);`
`113`	`116`	`this->ExecuteEvent("core", "OnAllPluginsLoaded", ss.str(), event);`
`114`	`117`	`delete event;`
`115`	`118`	`AllPluginsStarted = true;`
`116`	`119`	`}`
`117`	`120`
`118`	`121`	`void PluginManager::StopPlugins()`
`119`	`122`	`{`
`120`		`- for (Plugin *plugin : pluginsList)`
	`123`	`+ for (Plugin* plugin : pluginsList)`
`121`	`124`	`StopPlugin(plugin->GetName());`
`122`	`125`	`}`
`123`	`126`
`@@ -126,7 +129,7 @@ bool PluginManager::StartPlugin(std::string plugin_name)`
`126`	`129`	`if (!PluginExists(plugin_name))`
`127`	`130`	`return false;`
`128`	`131`
`129`		`- Plugin *plugin = pluginsMap.at(plugin_name);`
	`132`	`+ Plugin* plugin = pluginsMap.at(plugin_name);`
`130`	`133`	`if (plugin->GetPluginState() == PluginState_t::Started)`
`131`	`134`	`return true;`
`132`	`135`
`@@ -143,7 +146,7 @@ bool PluginManager::StartPlugin(std::string plugin_name)`
`143`	`146`
`144`	`147`	`msgpack::pack(ss, eventData);`
`145`	`148`
`146`		`- PluginEvent *event = new PluginEvent("core", nullptr, nullptr);`
	`149`	`+ PluginEvent* event = new PluginEvent("core", nullptr, nullptr);`
`147`	`150`	`plugin->TriggerEvent("core", "OnAllPluginsLoaded", ss.str(), event);`
`148`	`151`	`delete event;`
`149`	`152`	`}`
`@@ -156,7 +159,7 @@ void PluginManager::StopPlugin(std::string plugin_name)`
`156`	`159`	`if (!PluginExists(plugin_name))`
`157`	`160`	`return;`
`158`	`161`
`159`		`- Plugin *plugin = pluginsMap.at(plugin_name);`
	`162`	`+ Plugin* plugin = pluginsMap.at(plugin_name);`
`160`	`163`	`if (plugin->GetPluginState() == PluginState_t::Stopped)`
`161`	`164`	`return;`
`162`	`165`
`@@ -167,17 +170,17 @@ void PluginManager::StopPlugin(std::string plugin_name)`
`167`	`170`	`g_MenuManager->UnregisterPluginMenus(plugin_name);`
`168`	`171`	`}`
`169`	`172`
`170`		`-Plugin *PluginManager::FetchPlugin(std::string name)`
	`173`	`+Plugin* PluginManager::FetchPlugin(std::string name)`
`171`	`174`	`{`
`172`	`175`	`if (!PluginExists(name))`
`173`	`176`	`return nullptr;`
`174`	`177`
`175`	`178`	`return pluginsMap.at(name);`
`176`	`179`	`}`
`177`	`180`
`178`		`-EventResult PluginManager::ExecuteEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent *event)`
	`181`	`+EventResult PluginManager::ExecuteEvent(std::string invokedBy, std::string eventName, std::string eventPayload, PluginEvent* event)`
`179`	`182`	`{`
`180`		`- for (Plugin *plugin : this->pluginsList)`
	`183`	`+ for (Plugin* plugin : this->pluginsList)`
`181`	`184`	`{`
`182`	`185`	`EventResult result = plugin->TriggerEvent(invokedBy, eventName, eventPayload, event);`
`183`	`186`	`if (result != EventResult::Continue)`
`@@ -187,7 +190,7 @@ EventResult PluginManager::ExecuteEvent(std::string invokedBy, std::string event`
`187`	`190`	`return EventResult::Continue;`
`188`	`191`	`}`
`189`	`192`
`190`		`-std::vector<Plugin *> PluginManager::GetPluginsList()`
	`193`	`+std::vector<Plugin*> PluginManager::GetPluginsList()`
`191`	`194`	`{`
`192`	`195`	`return this->pluginsList;`
`193`	`196`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ std::string scripting_GetPluginPath(std::string plugin_name)`
`41`	`41`	`Plugin* plugin = g_pluginManager->FetchPlugin(plugin_name);`
`42`	`42`	`if (!plugin) return "";`
`43`	`43`
`44`		`- return string_format("addons/swiftly/plugins/%s", plugin->GetName().c_str());`
	`44`	`+ return string_format("%s/%s", pluginBasePaths[plugin_name].c_str(), plugin->GetName().c_str());`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`PluginUserMessage scripting_GetUserMessage(std::string uuid)`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ bool LuaPlugin::LoadScriptingEnvironment()`
`102`	`102`
`103`	`103`	`luabridge::setGlobal(this->state, NULL, "AddGlobalEvents");`
`104`	`104`
`105`		`- std::vector<std::string> files = Files::FetchFileNames("addons/swiftly/plugins/" + this->GetName());`
	`105`	`+ std::vector<std::string> files = Files::FetchFileNames(pluginBasePaths[this->GetName()] + "/" + this->GetName());`
`106`	`106`	`for (std::string file : files)`
`107`	`107`	`{`
`108`	`108`	`if (ends_with(file, ".lua"))`