summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/commands/cmd_clearcache.cpp6
-rw-r--r--src/commands/cmd_mode.cpp9
-rw-r--r--src/modmanager_dynamic.cpp328
-rw-r--r--src/modmanager_static.cpp127
-rw-r--r--src/modules.cpp304
-rw-r--r--src/modules/extra/m_mysql.cpp2
-rw-r--r--src/modules/extra/m_pgsql.cpp2
-rw-r--r--src/modules/extra/m_sqlite3.cpp2
-rw-r--r--src/modules/m_sqlv2.h4
9 files changed, 460 insertions, 324 deletions
diff --git a/src/commands/cmd_clearcache.cpp b/src/commands/cmd_clearcache.cpp
index 2334e597c..1fc8a1241 100644
--- a/src/commands/cmd_clearcache.cpp
+++ b/src/commands/cmd_clearcache.cpp
@@ -13,9 +13,6 @@
#include "inspircd.h"
-#ifndef __CMD_ADMIN_H__
-#define __CMD_ADMIN_H__
-
#include "users.h"
#include "channels.h"
#include "ctables.h"
@@ -40,9 +37,6 @@ class CommandClearcache : public Command
CmdResult Handle(const std::vector<std::string>& parameters, User *user);
};
-#endif
-
-
/** Handle /CLEARCACHE
*/
CmdResult CommandClearcache::Handle (const std::vector<std::string>& parameters, User *user)
diff --git a/src/commands/cmd_mode.cpp b/src/commands/cmd_mode.cpp
index 3cfc58263..5bc55e895 100644
--- a/src/commands/cmd_mode.cpp
+++ b/src/commands/cmd_mode.cpp
@@ -13,13 +13,6 @@
#include "inspircd.h"
-#ifndef __CMD_ADMIN_H__
-#define __CMD_ADMIN_H__
-
-#include "users.h"
-#include "channels.h"
-#include "ctables.h"
-
/** Handle /MODE. These command handlers can be reloaded by the core,
* and handle basic RFC1459 commands. Commands within modules work
* the same way, however, they can be fully unloaded, where these
@@ -40,8 +33,6 @@ class CommandMode : public Command
CmdResult Handle(const std::vector<std::string>& parameters, User *user);
};
-#endif
-
/** Handle /MODE
*/
diff --git a/src/modmanager_dynamic.cpp b/src/modmanager_dynamic.cpp
new file mode 100644
index 000000000..b4a1d5906
--- /dev/null
+++ b/src/modmanager_dynamic.cpp
@@ -0,0 +1,328 @@
+/* +------------------------------------+
+ * | Inspire Internet Relay Chat Daemon |
+ * +------------------------------------+
+ *
+ * InspIRCd: (C) 2002-2009 InspIRCd Development Team
+ * See: http://wiki.inspircd.org/Credits
+ *
+ * This program is free but copyrighted software; see
+ * the file COPYING for details.
+ *
+ * ---------------------------------------------------
+ */
+
+#include "inspircd.h"
+#include "xline.h"
+#include "socket.h"
+#include "socketengine.h"
+#include "command_parse.h"
+#include "dns.h"
+#include "exitcodes.h"
+
+#ifndef PURE_STATIC
+
+bool ModuleManager::Load(const char* filename)
+{
+ /* Don't allow people to specify paths for modules, it doesn't work as expected */
+ if (strchr(filename, '/'))
+ return false;
+ /* Do we have a glob pattern in the filename?
+ * The user wants to load multiple modules which
+ * match the pattern.
+ */
+ if (strchr(filename,'*') || (strchr(filename,'?')))
+ {
+ int n_match = 0;
+ DIR* library = opendir(ServerInstance->Config->ModPath.c_str());
+ if (library)
+ {
+ /* Try and locate and load all modules matching the pattern */
+ dirent* entry = NULL;
+ while (0 != (entry = readdir(library)))
+ {
+ if (InspIRCd::Match(entry->d_name, filename, ascii_case_insensitive_map))
+ {
+ if (!this->Load(entry->d_name))
+ n_match++;
+ }
+ }
+ closedir(library);
+ }
+ /* Loadmodule will now return false if any one of the modules failed
+ * to load (but wont abort when it encounters a bad one) and when 1 or
+ * more modules were actually loaded.
+ */
+ return (n_match > 0 ? false : true);
+ }
+
+ char modfile[MAXBUF];
+ snprintf(modfile,MAXBUF,"%s/%s",ServerInstance->Config->ModPath.c_str(),filename);
+ std::string filename_str = filename;
+
+ if (!ServerConfig::FileExists(modfile))
+ {
+ LastModuleError = "Module file could not be found: " + filename_str;
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ return false;
+ }
+
+ if (Modules.find(filename_str) != Modules.end())
+ {
+ LastModuleError = "Module " + filename_str + " is already loaded, cannot load a module twice!";
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ return false;
+ }
+
+ Module* newmod = NULL;
+ DLLManager* newhandle = new DLLManager(modfile);
+
+ try
+ {
+ newmod = newhandle->callInit();
+
+ if (newmod)
+ {
+ newmod->ModuleSourceFile = filename_str;
+ newmod->ModuleDLLManager = newhandle;
+ Version v = newmod->GetVersion();
+
+ ServerInstance->Logs->Log("MODULE", DEFAULT,"New module introduced: %s (Module version %s)%s",
+ filename, v.version.c_str(), (!(v.Flags & VF_VENDOR) ? " [3rd Party]" : " [Vendor]"));
+
+ Modules[filename_str] = newmod;
+ }
+ else
+ {
+ LastModuleError = "Unable to load " + filename_str + ": " + newhandle->LastError();
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ delete newhandle;
+ return false;
+ }
+ }
+ catch (CoreException& modexcept)
+ {
+ // failure in module constructor
+ delete newmod;
+ delete newhandle;
+ LastModuleError = "Unable to load " + filename_str + ": " + modexcept.GetReason();
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ return false;
+ }
+
+ this->ModCount++;
+ FOREACH_MOD(I_OnLoadModule,OnLoadModule(newmod));
+
+ /* We give every module a chance to re-prioritize when we introduce a new one,
+ * not just the one thats loading, as the new module could affect the preference
+ * of others
+ */
+ for(int tries = 0; tries < 20; tries++)
+ {
+ prioritizationState = tries > 0 ? PRIO_STATE_LAST : PRIO_STATE_FIRST;
+ for (std::map<std::string, Module*>::iterator n = Modules.begin(); n != Modules.end(); ++n)
+ n->second->Prioritize();
+
+ if (prioritizationState == PRIO_STATE_LAST)
+ break;
+ if (tries == 19)
+ ServerInstance->Logs->Log("MODULE", DEFAULT, "Hook priority dependency loop detected while loading " + filename_str);
+ }
+
+ ServerInstance->BuildISupport();
+ return true;
+}
+
+bool ModuleManager::CanUnload(Module* mod)
+{
+ std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
+
+ if (modfind == Modules.end() || modfind->second != mod)
+ {
+ LastModuleError = "Module " + mod->ModuleSourceFile + " is not loaded, cannot unload it!";
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ return false;
+ }
+ if (mod->GetVersion().Flags & VF_STATIC)
+ {
+ LastModuleError = "Module " + mod->ModuleSourceFile + " not unloadable (marked static)";
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ return false;
+ }
+ std::pair<int,std::string> intercount = GetInterfaceInstanceCount(mod);
+ if (intercount.first > 0)
+ {
+ LastModuleError = "Failed to unload module " + mod->ModuleSourceFile + ", being used by " + ConvToStr(intercount.first) + " other(s) via interface '" + intercount.second + "'";
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ return false;
+ }
+ return true;
+}
+
+void ModuleManager::DoSafeUnload(Module* mod)
+{
+ std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
+
+ std::vector<reference<ExtensionItem> > items;
+ ServerInstance->Extensions.BeginUnregister(modfind->second, items);
+ /* Give the module a chance to tidy out all its metadata */
+ for (chan_hash::iterator c = ServerInstance->chanlist->begin(); c != ServerInstance->chanlist->end(); c++)
+ {
+ mod->OnCleanup(TYPE_CHANNEL,c->second);
+ c->second->doUnhookExtensions(items);
+ const UserMembList* users = c->second->GetUsers();
+ for(UserMembCIter mi = users->begin(); mi != users->end(); mi++)
+ mi->second->doUnhookExtensions(items);
+ }
+ for (user_hash::iterator u = ServerInstance->Users->clientlist->begin(); u != ServerInstance->Users->clientlist->end(); u++)
+ {
+ mod->OnCleanup(TYPE_USER,u->second);
+ u->second->doUnhookExtensions(items);
+ }
+ for(char m='A'; m <= 'z'; m++)
+ {
+ ModeHandler* mh;
+ mh = ServerInstance->Modes->FindMode(m, MODETYPE_USER);
+ if (mh && mh->creator == mod)
+ ServerInstance->Modes->DelMode(mh);
+ mh = ServerInstance->Modes->FindMode(m, MODETYPE_CHANNEL);
+ if (mh && mh->creator == mod)
+ ServerInstance->Modes->DelMode(mh);
+ }
+
+ /* Tidy up any dangling resolvers */
+ ServerInstance->Res->CleanResolvers(mod);
+
+ FOREACH_MOD(I_OnUnloadModule,OnUnloadModule(mod));
+
+ DetachAll(mod);
+
+ Modules.erase(modfind);
+ ServerInstance->GlobalCulls.AddItem(mod);
+
+ ServerInstance->Logs->Log("MODULE", DEFAULT,"Module %s unloaded",mod->ModuleSourceFile.c_str());
+ this->ModCount--;
+ ServerInstance->BuildISupport();
+}
+
+namespace {
+ struct UnloadAction : public HandlerBase0<void>
+ {
+ Module* const mod;
+ UnloadAction(Module* m) : mod(m) {}
+ void Call()
+ {
+ DLLManager* dll = mod->ModuleDLLManager;
+ ServerInstance->Modules->DoSafeUnload(mod);
+ ServerInstance->GlobalCulls.Apply();
+ delete dll;
+ ServerInstance->GlobalCulls.AddItem(this);
+ }
+ };
+
+ struct ReloadAction : public HandlerBase0<void>
+ {
+ Module* const mod;
+ HandlerBase1<void, bool>* const callback;
+ ReloadAction(Module* m, HandlerBase1<void, bool>* c)
+ : mod(m), callback(c) {}
+ void Call()
+ {
+ DLLManager* dll = mod->ModuleDLLManager;
+ std::string name = mod->ModuleSourceFile;
+ ServerInstance->Modules->DoSafeUnload(mod);
+ ServerInstance->GlobalCulls.Apply();
+ delete dll;
+ bool rv = ServerInstance->Modules->Load(name.c_str());
+ callback->Call(rv);
+ ServerInstance->GlobalCulls.AddItem(this);
+ }
+ };
+}
+
+bool ModuleManager::Unload(Module* mod)
+{
+ if (!CanUnload(mod))
+ return false;
+ ServerInstance->AtomicActions.AddAction(new UnloadAction(mod));
+ return true;
+}
+
+void ModuleManager::Reload(Module* mod, HandlerBase1<void, bool>* callback)
+{
+ if (CanUnload(mod))
+ ServerInstance->AtomicActions.AddAction(new ReloadAction(mod, callback));
+ else
+ callback->Call(false);
+}
+
+/* We must load the modules AFTER initializing the socket engine, now */
+void ModuleManager::LoadAll()
+{
+ ModCount = 0;
+
+ printf("\nLoading core commands");
+ fflush(stdout);
+
+ DIR* library = opendir(ServerInstance->Config->ModPath.c_str());
+ if (library)
+ {
+ dirent* entry = NULL;
+ while (0 != (entry = readdir(library)))
+ {
+ if (InspIRCd::Match(entry->d_name, "cmd_*.so", ascii_case_insensitive_map))
+ {
+ printf(".");
+ fflush(stdout);
+
+ if (!Load(entry->d_name))
+ {
+ ServerInstance->Logs->Log("MODULE", DEFAULT, this->LastError());
+ printf_c("\n[\033[1;31m*\033[0m] %s\n\n", this->LastError().c_str());
+ ServerInstance->Exit(EXIT_STATUS_MODULE);
+ }
+ }
+ }
+ closedir(library);
+ printf("\n");
+ }
+
+ ConfigTagList tags = ServerInstance->Config->ConfTags("module");
+ for(ConfigIter i = tags.first; i != tags.second; ++i)
+ {
+ ConfigTag* tag = i->second;
+ std::string name = tag->getString("name");
+ printf_c("[\033[1;32m*\033[0m] Loading module:\t\033[1;32m%s\033[0m\n",name.c_str());
+
+ if (!this->Load(name.c_str()))
+ {
+ ServerInstance->Logs->Log("MODULE", DEFAULT, this->LastError());
+ printf_c("\n[\033[1;31m*\033[0m] %s\n\n", this->LastError().c_str());
+ ServerInstance->Exit(EXIT_STATUS_MODULE);
+ }
+ }
+}
+
+void ModuleManager::UnloadAll()
+{
+ /* We do this more than once, so that any service providers get a
+ * chance to be unhooked by the modules using them, but then get
+ * a chance to be removed themsleves.
+ *
+ * Note: this deliberately does NOT delete the DLLManager objects
+ */
+ for (int tries = 0; tries < 4; tries++)
+ {
+ std::map<std::string, Module*>::iterator i = Modules.begin();
+ while (i != Modules.end())
+ {
+ std::map<std::string, Module*>::iterator me = i++;
+ if (CanUnload(me->second))
+ {
+ DoSafeUnload(me->second);
+ }
+ }
+ ServerInstance->GlobalCulls.Apply();
+ }
+}
+
+#endif
diff --git a/src/modmanager_static.cpp b/src/modmanager_static.cpp
new file mode 100644
index 000000000..e09310a13
--- /dev/null
+++ b/src/modmanager_static.cpp
@@ -0,0 +1,127 @@
+#include "inspircd.h"
+
+#ifdef PURE_STATIC
+
+static std::vector<AllCommandList::fn>* cmdlist = NULL;
+static std::vector<AllModuleList*>* modlist = NULL;
+
+AllCommandList::AllCommandList(fn cmd)
+{
+ if (!cmdlist)
+ cmdlist = new std::vector<AllCommandList::fn>();
+ cmdlist->push_back(cmd);
+}
+
+AllModuleList::AllModuleList(AllModuleList::fn mod, const std::string& Name) : init(mod), name(Name)
+{
+ if (!modlist)
+ modlist = new std::vector<AllModuleList*>();
+ modlist->push_back(this);
+}
+
+class AllModule : public Module
+{
+ std::vector<Command*> cmds;
+ public:
+ AllModule()
+ {
+ if (!cmdlist)
+ return;
+ try
+ {
+ cmds.reserve(cmdlist->size());
+ for(std::vector<AllCommandList::fn>::iterator i = cmdlist->begin(); i != cmdlist->end(); ++i)
+ {
+ Command* c = (*i)(this);
+ cmds.push_back(c);
+ ServerInstance->AddCommand(c);
+ }
+ }
+ catch (...)
+ {
+ this->AllModule::~AllModule();
+ throw;
+ }
+ }
+
+ ~AllModule()
+ {
+ for(std::vector<Command*>::iterator i = cmds.begin(); i != cmds.end(); ++i)
+ delete *i;
+ }
+
+ Version GetVersion()
+ {
+ return Version("All commands", VF_VENDOR|VF_CORE);
+ }
+};
+
+MODULE_INIT(AllModule)
+
+bool ModuleManager::Load(const char* filename)
+{
+ return false;
+}
+
+bool ModuleManager::CanUnload(Module* mod)
+{
+ return false;
+}
+
+void ModuleManager::DoSafeUnload(Module* mod)
+{
+}
+
+bool ModuleManager::Unload(Module* mod)
+{
+ return false;
+}
+
+void ModuleManager::Reload(Module* mod, HandlerBase1<void, bool>* callback)
+{
+ callback->Call(false);
+}
+
+void ModuleManager::LoadAll()
+{
+ ModCount = 0;
+ for(std::vector<AllModuleList*>::iterator i = modlist->begin(); i != modlist->end(); ++i)
+ {
+ try
+ {
+ Module* c = (*(**i).init)();
+ c->ModuleSourceFile = (**i).name;
+ Modules[(**i).name] = c;
+ FOREACH_MOD(I_OnLoadModule,OnLoadModule(c));
+ }
+ catch (CoreException& modexcept)
+ {
+ ServerInstance->Logs->Log("MODULE", DEFAULT, "Unable to load " + (**i).name + ": " + modexcept.GetReason());
+ }
+ }
+
+ /* We give every module a chance to re-prioritize when we introduce a new one,
+ * not just the one thats loading, as the new module could affect the preference
+ * of others
+ */
+ for(int tries = 0; tries < 20; tries++)
+ {
+ prioritizationState = tries > 0 ? PRIO_STATE_LAST : PRIO_STATE_FIRST;
+ for (std::map<std::string, Module*>::iterator n = Modules.begin(); n != Modules.end(); ++n)
+ n->second->Prioritize();
+
+ if (prioritizationState == PRIO_STATE_LAST)
+ break;
+ if (tries == 19)
+ ServerInstance->Logs->Log("MODULE", DEFAULT, "Hook priority dependency loop detected");
+ }
+
+ ServerInstance->BuildISupport();
+}
+
+void ModuleManager::UnloadAll()
+{
+ // TODO don't really need this, who cares if we leak on exit?
+}
+
+#endif
diff --git a/src/modules.cpp b/src/modules.cpp
index b3aabf284..a2c4aa6ea 100644
--- a/src/modules.cpp
+++ b/src/modules.cpp
@@ -322,310 +322,6 @@ std::string& ModuleManager::LastError()
return LastModuleError;
}
-bool ModuleManager::Load(const char* filename)
-{
- /* Don't allow people to specify paths for modules, it doesn't work as expected */
- if (strchr(filename, '/'))
- return false;
- /* Do we have a glob pattern in the filename?
- * The user wants to load multiple modules which
- * match the pattern.
- */
- if (strchr(filename,'*') || (strchr(filename,'?')))
- {
- int n_match = 0;
- DIR* library = opendir(ServerInstance->Config->ModPath.c_str());
- if (library)
- {
- /* Try and locate and load all modules matching the pattern */
- dirent* entry = NULL;
- while (0 != (entry = readdir(library)))
- {
- if (InspIRCd::Match(entry->d_name, filename, ascii_case_insensitive_map))
- {
- if (!this->Load(entry->d_name))
- n_match++;
- }
- }
- closedir(library);
- }
- /* Loadmodule will now return false if any one of the modules failed
- * to load (but wont abort when it encounters a bad one) and when 1 or
- * more modules were actually loaded.
- */
- return (n_match > 0 ? false : true);
- }
-
- char modfile[MAXBUF];
- snprintf(modfile,MAXBUF,"%s/%s",ServerInstance->Config->ModPath.c_str(),filename);
- std::string filename_str = filename;
-
- if (!ServerConfig::FileExists(modfile))
- {
- LastModuleError = "Module file could not be found: " + filename_str;
- ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
- return false;
- }
-
- if (Modules.find(filename_str) != Modules.end())
- {
- LastModuleError = "Module " + filename_str + " is already loaded, cannot load a module twice!";
- ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
- return false;
- }
-
- Module* newmod = NULL;
- DLLManager* newhandle = new DLLManager(modfile);
-
- try
- {
- newmod = newhandle->callInit();
-
- if (newmod)
- {
- newmod->ModuleSourceFile = filename_str;
- newmod->ModuleDLLManager = newhandle;
- Version v = newmod->GetVersion();
-
- ServerInstance->Logs->Log("MODULE", DEFAULT,"New module introduced: %s (Module version %s)%s",
- filename, v.version.c_str(), (!(v.Flags & VF_VENDOR) ? " [3rd Party]" : " [Vendor]"));
-
- Modules[filename_str] = newmod;
- }
- else
- {
- LastModuleError = "Unable to load " + filename_str + ": " + newhandle->LastError();
- ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
- delete newhandle;
- return false;
- }
- }
- catch (CoreException& modexcept)
- {
- // failure in module constructor
- delete newmod;
- delete newhandle;
- LastModuleError = "Unable to load " + filename_str + ": " + modexcept.GetReason();
- ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
- return false;
- }
-
- this->ModCount++;
- FOREACH_MOD(I_OnLoadModule,OnLoadModule(newmod));
-
- /* We give every module a chance to re-prioritize when we introduce a new one,
- * not just the one thats loading, as the new module could affect the preference
- * of others
- */
- for(int tries = 0; tries < 20; tries++)
- {
- prioritizationState = tries > 0 ? PRIO_STATE_LAST : PRIO_STATE_FIRST;
- for (std::map<std::string, Module*>::iterator n = Modules.begin(); n != Modules.end(); ++n)
- n->second->Prioritize();
-
- if (prioritizationState == PRIO_STATE_LAST)
- break;
- if (tries == 19)
- ServerInstance->Logs->Log("MODULE", DEFAULT, "Hook priority dependency loop detected while loading " + filename_str);
- }
-
- ServerInstance->BuildISupport();
- return true;
-}
-
-bool ModuleManager::CanUnload(Module* mod)
-{
- std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
-
- if (modfind == Modules.end() || modfind->second != mod)
- {
- LastModuleError = "Module " + mod->ModuleSourceFile + " is not loaded, cannot unload it!";
- ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
- return false;
- }
- if (mod->GetVersion().Flags & VF_STATIC)
- {
- LastModuleError = "Module " + mod->ModuleSourceFile + " not unloadable (marked static)";
- ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
- return false;
- }
- std::pair<int,std::string> intercount = GetInterfaceInstanceCount(mod);
- if (intercount.first > 0)
- {
- LastModuleError = "Failed to unload module " + mod->ModuleSourceFile + ", being used by " + ConvToStr(intercount.first) + " other(s) via interface '" + intercount.second + "'";
- ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
- return false;
- }
- return true;
-}
-
-void ModuleManager::DoSafeUnload(Module* mod)
-{
- std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
-
- std::vector<reference<ExtensionItem> > items;
- ServerInstance->Extensions.BeginUnregister(modfind->second, items);
- /* Give the module a chance to tidy out all its metadata */
- for (chan_hash::iterator c = ServerInstance->chanlist->begin(); c != ServerInstance->chanlist->end(); c++)
- {
- mod->OnCleanup(TYPE_CHANNEL,c->second);
- c->second->doUnhookExtensions(items);
- const UserMembList* users = c->second->GetUsers();
- for(UserMembCIter mi = users->begin(); mi != users->end(); mi++)
- mi->second->doUnhookExtensions(items);
- }
- for (user_hash::iterator u = ServerInstance->Users->clientlist->begin(); u != ServerInstance->Users->clientlist->end(); u++)
- {
- mod->OnCleanup(TYPE_USER,u->second);
- u->second->doUnhookExtensions(items);
- }
- for(char m='A'; m <= 'z'; m++)
- {
- ModeHandler* mh;
- mh = ServerInstance->Modes->FindMode(m, MODETYPE_USER);
- if (mh && mh->creator == mod)
- ServerInstance->Modes->DelMode(mh);
- mh = ServerInstance->Modes->FindMode(m, MODETYPE_CHANNEL);
- if (mh && mh->creator == mod)
- ServerInstance->Modes->DelMode(mh);
- }
-
- /* Tidy up any dangling resolvers */
- ServerInstance->Res->CleanResolvers(mod);
-
- FOREACH_MOD(I_OnUnloadModule,OnUnloadModule(mod));
-
- DetachAll(mod);
-
- Modules.erase(modfind);
- ServerInstance->GlobalCulls.AddItem(mod);
-
- ServerInstance->Logs->Log("MODULE", DEFAULT,"Module %s unloaded",mod->ModuleSourceFile.c_str());
- this->ModCount--;
- ServerInstance->BuildISupport();
-}
-
-namespace {
- struct UnloadAction : public HandlerBase0<void>
- {
- Module* const mod;
- UnloadAction(Module* m) : mod(m) {}
- void Call()
- {
- DLLManager* dll = mod->ModuleDLLManager;
- ServerInstance->Modules->DoSafeUnload(mod);
- ServerInstance->GlobalCulls.Apply();
- delete dll;
- ServerInstance->GlobalCulls.AddItem(this);
- }
- };
-
- struct ReloadAction : public HandlerBase0<void>
- {
- Module* const mod;
- HandlerBase1<void, bool>* const callback;
- ReloadAction(Module* m, HandlerBase1<void, bool>* c)
- : mod(m), callback(c) {}
- void Call()
- {
- DLLManager* dll = mod->ModuleDLLManager;
- std::string name = mod->ModuleSourceFile;
- ServerInstance->Modules->DoSafeUnload(mod);
- ServerInstance->GlobalCulls.Apply();
- delete dll;
- bool rv = ServerInstance->Modules->Load(name.c_str());
- callback->Call(rv);
- ServerInstance->GlobalCulls.AddItem(this);
- }
- };
-}
-
-bool ModuleManager::Unload(Module* mod)
-{
- if (!CanUnload(mod))
- return false;
- ServerInstance->AtomicActions.AddAction(new UnloadAction(mod));
- return true;
-}
-
-void ModuleManager::Reload(Module* mod, HandlerBase1<void, bool>* callback)
-{
- if (CanUnload(mod))
- ServerInstance->AtomicActions.AddAction(new ReloadAction(mod, callback));
- else
- callback->Call(false);
-}
-
-/* We must load the modules AFTER initializing the socket engine, now */
-void ModuleManager::LoadAll()
-{
- ModCount = 0;
-
- printf("\nLoading core commands");
- fflush(stdout);
-
- DIR* library = opendir(ServerInstance->Config->ModPath.c_str());
- if (library)
- {
- dirent* entry = NULL;
- while (0 != (entry = readdir(library)))
- {
- if (InspIRCd::Match(entry->d_name, "cmd_*.so", ascii_case_insensitive_map))
- {
- printf(".");
- fflush(stdout);
-
- if (!Load(entry->d_name))
- {
- ServerInstance->Logs->Log("MODULE", DEFAULT, this->LastError());
- printf_c("\n[\033[1;31m*\033[0m] %s\n\n", this->LastError().c_str());
- ServerInstance->Exit(EXIT_STATUS_MODULE);
- }
- }
- }
- closedir(library);
- printf("\n");
- }
-
- ConfigTagList tags = ServerInstance->Config->ConfTags("module");
- for(ConfigIter i = tags.first; i != tags.second; ++i)
- {
- ConfigTag* tag = i->second;
- std::string name = tag->getString("name");
- printf_c("[\033[1;32m*\033[0m] Loading module:\t\033[1;32m%s\033[0m\n",name.c_str());
-
- if (!this->Load(name.c_str()))
- {
- ServerInstance->Logs->Log("MODULE", DEFAULT, this->LastError());
- printf_c("\n[\033[1;31m*\033[0m] %s\n\n", this->LastError().c_str());
- ServerInstance->Exit(EXIT_STATUS_MODULE);
- }
- }
-}
-
-void ModuleManager::UnloadAll()
-{
- /* We do this more than once, so that any service providers get a
- * chance to be unhooked by the modules using them, but then get
- * a chance to be removed themsleves.
- *
- * Note: this deliberately does NOT delete the DLLManager objects
- */
- for (int tries = 0; tries < 4; tries++)
- {
- std::map<std::string, Module*>::iterator i = Modules.begin();
- while (i != Modules.end())
- {
- std::map<std::string, Module*>::iterator me = i++;
- if (CanUnload(me->second))
- {
- DoSafeUnload(me->second);
- }
- }
- ServerInstance->GlobalCulls.Apply();
- }
-}
-
bool ModuleManager::PublishFeature(const std::string &FeatureName, Module* Mod)
{
if (Features.find(FeatureName) == Features.end())
diff --git a/src/modules/extra/m_mysql.cpp b/src/modules/extra/m_mysql.cpp
index 47de25ee4..358f5e992 100644
--- a/src/modules/extra/m_mysql.cpp
+++ b/src/modules/extra/m_mysql.cpp
@@ -70,7 +70,7 @@ class DispatcherThread;
typedef std::map<std::string, SQLConnection*> ConnMap;
typedef std::deque<SQLresult*> ResultQueue;
-unsigned long count(const char * const str, char a)
+static unsigned long count(const char * const str, char a)
{
unsigned long n = 0;
for (const char *p = str; *p; ++p)
diff --git a/src/modules/extra/m_pgsql.cpp b/src/modules/extra/m_pgsql.cpp
index b5beea0b0..f362125cb 100644
--- a/src/modules/extra/m_pgsql.cpp
+++ b/src/modules/extra/m_pgsql.cpp
@@ -44,7 +44,7 @@ typedef std::map<std::string, SQLConn*> ConnMap;
*/
enum SQLstatus { CREAD, CWRITE, WREAD, WWRITE, RREAD, RWRITE };
-unsigned long count(const char * const str, char a)
+static unsigned long count(const char * const str, char a)
{
unsigned long n = 0;
for (const char *p = str; *p; ++p)
diff --git a/src/modules/extra/m_sqlite3.cpp b/src/modules/extra/m_sqlite3.cpp
index 89f61b652..e5693b61f 100644
--- a/src/modules/extra/m_sqlite3.cpp
+++ b/src/modules/extra/m_sqlite3.cpp
@@ -31,7 +31,7 @@ typedef std::map<std::string, SQLConn*> ConnMap;
typedef std::deque<classbase*> paramlist;
typedef std::deque<SQLite3Result*> ResultQueue;
-unsigned long count(const char * const str, char a)
+static unsigned long count(const char * const str, char a)
{
unsigned long n = 0;
for (const char *p = str; *p; ++p)
diff --git a/src/modules/m_sqlv2.h b/src/modules/m_sqlv2.h
index 05079a8e6..7d1cb78f2 100644
--- a/src/modules/m_sqlv2.h
+++ b/src/modules/m_sqlv2.h
@@ -457,13 +457,13 @@ class SQLhost
/** Overload operator== for two SQLhost objects for easy comparison.
*/
-bool operator== (const SQLhost& l, const SQLhost& r)
+inline bool operator== (const SQLhost& l, const SQLhost& r)
{
return (l.id == r.id && l.host == r.host && l.port == r.port && l.name == r.name && l.user == r.user && l.pass == r.pass && l.ssl == r.ssl);
}
/** Overload operator!= for two SQLhost objects for easy comparison.
*/
-bool operator!= (const SQLhost& l, const SQLhost& r)
+inline bool operator!= (const SQLhost& l, const SQLhost& r)
{
return (l.id != r.id || l.host != r.host || l.port != r.port || l.name != r.name || l.user != r.user || l.pass != r.pass || l.ssl != r.ssl);
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 23:01:50 +0000