DLLFactory--

[user/henk/code/inspircd.git] / src / modules / m_password_hash.cpp

diff --git a/src/modules/m_password_hash.cpp b/src/modules/m_password_hash.cpp
index 52c8f241cb77382df7fdd016a053f0f8d4479c40..afc6cdd7946213ee468b8acbba71ceafbe20e21b 100644 (file)
--- a/src/modules/m_password_hash.cpp
+++ b/src/modules/m_password_hash.cpp
@@ -12,7 +12,6 @@
  */
 
 /* $ModDesc: Allows for hashed oper passwords */
-/* $ModDep: m_hash.h */
 
 #include "inspircd.h"
 #include "m_hash.h"
@@ -23,15 +22,13 @@ typedef std::map<irc::string, Module*> hashymodules;
  */
 class CommandMkpasswd : public Command
 {
-       Module* Sender;
        hashymodules &hashers;
        std::deque<std::string> &names;
  public:
-       CommandMkpasswd (InspIRCd* Instance, Module* S, hashymodules &h, std::deque<std::string> &n)
-               : Command(Instance,"MKPASSWD", 0, 2), Sender(S), hashers(h), names(n)
+       CommandMkpasswd(Module* Creator, hashymodules &h, std::deque<std::string> &n) : Command(Creator, "MKPASSWD", 2), hashers(h), names(n)
        {
-               this->source = "m_password_hash.so";
                syntax = "<hashtype> <any-text>";
+               Penalty = 5;
        }
 
        void MakeHash(User* user, const char* algo, const char* stuff)
@@ -40,10 +37,10 @@ class CommandMkpasswd : public Command
                hashymodules::iterator x = hashers.find(algo);
                if (x != hashers.end())
                {
-                       /* Yup, reset it first (Always ALWAYS do this) */
-                       HashResetRequest(Sender, x->second).Send();
+                       HashRequest hash(creator, x->second, stuff);
                        /* Now attempt to generate a hash */
-                       user->WriteServ("NOTICE %s :%s hashed password for %s is %s",user->nick.c_str(), algo, stuff, HashSumRequest(Sender, x->second, stuff).Send() );
+                       user->WriteServ("NOTICE %s :%s hashed password for %s is %s",
+                               user->nick.c_str(), algo, stuff, hash.hex().c_str());
                }
                else if (names.empty())
                {
@@ -60,26 +57,23 @@ class CommandMkpasswd : public Command
        CmdResult Handle (const std::vector<std::string>& parameters, User *user)
        {
                MakeHash(user, parameters[0].c_str(), parameters[1].c_str());
-               // this hashing could take some time, increasing server load.
-               // Slow down the user if they are trying to flood mkpasswd requests
-               user->IncreasePenalty(5);
 
-               return CMD_LOCALONLY;
+               return CMD_SUCCESS;
        }
 };
 
 class ModuleOperHash : public Module
 {
 
-       CommandMkpasswd* mycommand;
+       CommandMkpasswd cmd;
        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)
+       ModuleOperHash()
+               : cmd(this, hashers, names)
        {
                diduseiface = false;
 
@@ -99,7 +93,7 @@ class ModuleOperHash : public Module
                                /* Make a request to it for its name, its implementing
                                 * HashRequest so we know its safe to do this
                                 */
-                               std::string name = HashNameRequest(this, *m).Send();
+                               std::string name = HashNameRequest(this, *m).response;
                                /* Build a map of them */
                                hashers[name.c_str()] = *m;
                                names.push_back(name);
@@ -109,8 +103,7 @@ class ModuleOperHash : public Module
                        diduseiface = true;
                }
 
-               mycommand = new CommandMkpasswd(ServerInstance, this, hashers, names);
-               ServerInstance->AddCommand(mycommand);
+               ServerInstance->AddCommand(&cmd);
                Implementation eventlist[] = { I_OnPassCompare, I_OnLoadModule };
                ServerInstance->Modules->Attach(eventlist, this, 2);
        }
@@ -126,7 +119,7 @@ class ModuleOperHash : public Module
                if (ServerInstance->Modules->ModuleHasInterface(mod, "HashRequest"))
                {
                        ServerInstance->Logs->Log("m_password-hash",DEBUG, "Post-load registering hasher: %s", name.c_str());
-                       std::string sname = HashNameRequest(this, mod).Send();
+                       std::string sname = HashNameRequest(this, mod).response;
                        hashers[sname.c_str()] = mod;
                        names.push_back(sname);
                        if (!diduseiface)
@@ -137,7 +130,7 @@ class ModuleOperHash : public Module
                }
        }
 
-       virtual int OnPassCompare(Extensible* ex, const std::string &data, const std::string &input, const std::string &hashtype)
+       virtual ModResult OnPassCompare(Extensible* ex, const std::string &data, const std::string &input, const std::string &hashtype)
        {
                /* First, lets see what hash theyre using on this oper */
                hashymodules::iterator x = hashers.find(hashtype.c_str());
@@ -145,22 +138,21 @@ class ModuleOperHash : public Module
                /* Is this a valid hash name? (case insensitive) */
                if (x != hashers.end())
                {
-                       /* Reset the hashing module */
-                       HashResetRequest(this, x->second).Send();
                        /* Compare the hash in the config to the generated hash */
-                       if (!strcasecmp(data.c_str(), HashSumRequest(this, x->second, input.c_str()).Send()))
-                               return 1;
+                       if (!strcasecmp(data.c_str(), HashRequest(this, x->second, input).hex().c_str()))
+                               return MOD_RES_ALLOW;
                        /* No match, and must be hashed, forbid */
-                       else return -1;
+                       else
+                               return MOD_RES_DENY;
                }
 
                /* Not a hash, fall through to strcmp in core */
-               return 0;
+               return MOD_RES_PASSTHRU;
        }
 
        virtual Version GetVersion()
        {
-               return Version("$Id$",VF_VENDOR,API_VERSION);
+               return Version("Allows for hashed oper passwords",VF_VENDOR,API_VERSION);
        }
 };