Make m_password_hash able to pick up hasher modules after it's loaded, meaning m_md5 and m_sha256 no longer have to be loaded before it.

git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@8793 e03df62e-2008-0410-955e-edbf42e46eb7

4 files changed, 43 insertions, 17 deletions

diff --git a/.Makefile.inc b/.Makefile.inc
index c753bda94..a8c762276 100644
--- a/.Makefile.inc
+++ b/.Makefile.inc
@@ -22,7 +22,7 @@ LAUNCHDPATH = $(DESTDIR)/System/Library/LaunchDaemons
 LIBPATH = $(DESTDIR)@LIBRARY_DIR@
 MODULES = @MODULES@
 INSTMODE = 0755
-MAKEARGS = 'PROGS=${PROGS}' 'FLAGS=${FLAGS}' 'CC=${CC}' 'LDLIBS=${LDLIBS}' 'MODULES=${MODULES}' 'MODPATH=${MODPATH}' 'LIBPATH=${LIBPATH}' 'INSTMODE=${INSTMODE}'
+MAKEARGS = 'PROGS=${PROGS}' 'FLAGS=${FLAGS}' 'NICEFLAGS=${NICEFLAGS}' 'CC=${CC}' 'LDLIBS=${LDLIBS}' 'MODULES=${MODULES}' 'MODPATH=${MODPATH}' 'LIBPATH=${LIBPATH}' 'INSTMODE=${INSTMODE}'
 
 all: @MAKEORDER@ finishmessage
 
diff --git a/include/modules.h b/include/modules.h
index 1cb3d36c5..e14b13c9b 100644
--- a/include/modules.h
+++ b/include/modules.h
@@ -1824,6 +1824,14 @@ class CoreExport ModuleManager : public classbase
 	 */
 	modulelist* FindInterface(const std::string &InterfaceName);
 
+	/** Determine if a module has published the named interface.
+	 * This could be used in, for example, OnLoadModule to pick up other modules that can be used.
+	 * @param mod The module to check.
+	 * @param InterfaceName the interface you want to check for
+	 * @return True if the module provides the interface, false otherwise.
+	 */
+	bool ModuleHasInterface(Module* mod, const std::string& InterfaceName);
+
 	/** Given a pointer to a Module, return its filename
 	 * @param m The module pointer to identify
 	 * @return The module name or an empty string
diff --git a/src/modules.cpp b/src/modules.cpp
index 25a53fefe..6cc1a3450 100644
--- a/src/modules.cpp
+++ b/src/modules.cpp
@@ -641,6 +641,19 @@ modulelist* ModuleManager::FindInterface(const std::string &InterfaceName)
 		return &(iter->second.second);
 }
 
+bool ModuleManager::ModuleHasInterface(Module* mod, const std::string& InterfaceName)
+{
+	interfacelist::iterator iter = Interfaces.find(InterfaceName);
+	if (iter == Interfaces.end())
+		return false;
+	else
+	{
+		modulelist& ml = iter->second.second;
+		modulelist::iterator mi = std::find(ml.begin(), ml.end(), mod);
+		return (mi != ml.end());
+	}
+}
+
 void ModuleManager::UseInterface(const std::string &InterfaceName)
 {
 	interfacelist::iterator iter = Interfaces.find(InterfaceName);
diff --git a/src/modules/m_password_hash.cpp b/src/modules/m_password_hash.cpp
index 476202616..baf73e113 100644
--- a/src/modules/m_password_hash.cpp
+++ b/src/modules/m_password_hash.cpp
@@ -67,18 +67,19 @@ class ModuleOperHash : public Module
 {
 	
 	CommandMkpasswd* mycommand;
-	ConfigReader* Conf;
 	hashymodules hashers; /* List of modules which implement HashRequest */
 	std::deque<std::string> names; /* Module names which implement HashRequest */
 
+	bool diduseiface; /* If we've called UseInterface yet. */
  public:
 
 	ModuleOperHash(InspIRCd* Me)
 		: Module(Me)
 	{
+		diduseiface = false;
 
 		/* Read the config file first */
-		Conf = NULL;
+//		Conf = NULL;
 		OnRehash(NULL,"");
 
 		/* Find all modules which implement the interface 'HashRequest' */
@@ -98,33 +99,37 @@ class ModuleOperHash : public Module
 				hashers[name.c_str()] = *m;
 				names.push_back(name);
 			}
-		}
-		else
-		{
-			throw ModuleException("I can't find any modules loaded which implement the HashRequest interface! You probably forgot to load a hashing module such as m_md5.so or m_sha256.so.");
+			/* UseInterface doesn't do anything if there are no providers, so we'll have to call it later if a module gets loaded later on. */
+			ServerInstance->Modules->UseInterface("HashRequest");
+			diduseiface = true;
 		}
 
-		ServerInstance->Modules->UseInterface("HashRequest");
-
 		mycommand = new CommandMkpasswd(ServerInstance, this, hashers, names);
 		ServerInstance->AddCommand(mycommand);
-		Implementation eventlist[] = { I_OnRehash, I_OnPassCompare };
+		Implementation eventlist[] = { I_OnPassCompare, I_OnLoadModule };
 		ServerInstance->Modules->Attach(eventlist, this, 2);
 	}
 	
 	virtual ~ModuleOperHash()
 	{
-		ServerInstance->Modules->DoneWithInterface("HashRequest");
+		if (diduseiface) ServerInstance->Modules->DoneWithInterface("HashRequest");
 	}
 
 
-	virtual void OnRehash(User* user, const std::string &parameter)
+	virtual void OnLoadModule(Module* mod, const std::string& name)
 	{
-		/* Re-read configuration file */
-		if (Conf)
-			delete Conf;
-
-		Conf = new ConfigReader(ServerInstance);
+		if (ServerInstance->Modules->ModuleHasInterface(mod, "HashRequest"))
+		{
+			ServerInstance->Log(DEBUG, "Post-load registering hasher: %s", name.c_str());
+			std::string name = HashNameRequest(this, mod).Send();
+			hashers[name.c_str()] = mod;
+			names.push_back(name);
+			if (!diduseiface)
+			{
+				ServerInstance->Modules->UseInterface("HashRequest");
+				diduseiface = true;
+			}
+		}
 	}
 
 	virtual int OnPassCompare(Extensible* ex, const std::string &data, const std::string &input, const std::string &hashtype)