If the user's nick is just a case change, the TS is NOT updated (thanks jilles)

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

diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp
index 49f490e83127ae89cd2f78d4aac6ec908f33cdc9..9d7b7db790afbcca368aae49548ece4d289dd6c9 100644 (file)
--- a/src/modules/m_spanningtree/main.cpp
+++ b/src/modules/m_spanningtree/main.cpp
@@ -14,10 +14,6 @@
 /* $ModDesc: Provides a spanning tree server link protocol */
 
 #include "inspircd.h"
-#include "configreader.h"
-#include "users.h"
-#include "channels.h"
-#include "modules.h"
 #include "commands/cmd_whois.h"
 #include "commands/cmd_stats.h"
 #include "socket.h"
@@ -248,7 +244,7 @@ int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* u
                if (s)
                {
                        params[0] = s->GetName();
-                       Utils->DoOneToOne(user->nick, "MOTD", params, s->GetName());
+                       Utils->DoOneToOne(user->uuid, "MOTD", params, s->GetName());
                }
                else
                        user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
@@ -272,7 +268,7 @@ int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec*
                if (s)
                {
                        params[0] = s->GetName();
-                       Utils->DoOneToOne(user->nick, "ADMIN", params, s->GetName());
+                       Utils->DoOneToOne(user->uuid, "ADMIN", params, s->GetName());
                }
                else
                        user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
@@ -294,7 +290,7 @@ int ModuleSpanningTree::HandleModules(const char** parameters, int pcnt, userrec
                if (s)
                {
                        params[0] = s->GetName();
-                       Utils->DoOneToOne(user->nick, "MODULES", params, s->GetName());
+                       Utils->DoOneToOne(user->uuid, "MODULES", params, s->GetName());
                }
                else
                        user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
@@ -320,7 +316,7 @@ int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, userrec*
                if (s)
                {
                        params[1] = s->GetName();
-                       Utils->DoOneToOne(user->nick, "STATS", params, s->GetName());
+                       Utils->DoOneToOne(user->uuid, "STATS", params, s->GetName());
                }
                else
                {
@@ -439,8 +435,8 @@ int ModuleSpanningTree::HandleTime(const char** parameters, int pcnt, userrec* u
                        
                        std::deque<std::string> params;
                        params.push_back(found->GetName());
-                       params.push_back(user->nick);
-                       Utils->DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName());
+                       params.push_back(user->uuid);
+                       Utils->DoOneToOne(ServerInstance->Config->GetSID(),"TIME",params,found->GetName());
                }
                else
                {
@@ -459,7 +455,7 @@ int ModuleSpanningTree::HandleRemoteWhois(const char** parameters, int pcnt, use
                {
                        std::deque<std::string> params;
                        params.push_back(parameters[1]);
-                       Utils->DoOneToOne(user->nick,"IDLE",params,remote->server);
+                       Utils->DoOneToOne(user->uuid,"IDLE",params,remote->server);
                        return 1;
                }
                else if (!remote)
@@ -484,7 +480,7 @@ void ModuleSpanningTree::DoPingChecks(time_t curtime)
                        {
                                if (serv->AnsweredLastPing())
                                {
-                                       sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName());
+                                       sock->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" PING "+serv->GetName());
                                        serv->SetNextPingTime(curtime + Utils->PingFreq);
                                        serv->LastPing = curtime;
                                        timeval t;
@@ -647,7 +643,7 @@ void ModuleSpanningTree::RemoteMessage(userrec* user, const char* format, ...)
                ServerInstance->SNO->WriteToSnoMask('l', "%s", text);
                params.push_back("l");
                params.push_back(std::string(":") + text);
-               Utils->DoOneToMany(ServerInstance->Config->ServerName, "SNONOTICE", params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(), "SNONOTICE", params);
        }
        else
        {
@@ -655,10 +651,10 @@ void ModuleSpanningTree::RemoteMessage(userrec* user, const char* format, ...)
                        user->WriteServ("NOTICE %s :%s", user->nick, text);
                else
                {
-                       params.push_back(user->nick);
+                       params.push_back(user->uuid);
                        params.push_back(std::string("::") + ServerInstance->Config->ServerName + " NOTICE " + user->nick + " :*** From " +
                                        ServerInstance->Config->ServerName+ ": " + text);
-                       Utils->DoOneToMany(ServerInstance->Config->ServerName, "PUSH", params);
+                       Utils->DoOneToMany(ServerInstance->Config->GetSID(), "PUSH", params);
                }
        }
 }
@@ -694,7 +690,7 @@ void ModuleSpanningTree::BroadcastTimeSync()
                std::deque<std::string> params;
                params.push_back(ConvToStr(ServerInstance->Time(false)));
                params.push_back("FORCE");
-               Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(), "TIMESET", params);
        }
 }
 
@@ -803,6 +799,8 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const char**
 {
        if ((result == CMD_SUCCESS) && (ServerInstance->IsValidModuleCommand(command, pcnt, user)))
        {
+               /* Safe, we know its non-null because IsValidModuleCommand returned true */
+               command_t* thiscmd = ServerInstance->Parser->GetHandler(command);
                // this bit of code cleverly routes all module commands
                // to all remote severs *automatically* so that modules
                // can just handle commands locally, without having
@@ -810,16 +808,29 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const char**
                // commands and linking protocols.
                std::deque<std::string> params;
                params.clear();
+               int n_translate = thiscmd->translation.size();
+               TranslateType translate_to;
+
                for (int j = 0; j < pcnt; j++)
                {
-                       if (strchr(parameters[j],' '))
+                       std::string target;
+
+                       /* Map all items to UUIDs where neccessary */
+                       if (j < n_translate)
                        {
-                               params.push_back(":" + std::string(parameters[j]));
+                               /* We have a translation mapping for this index */
+                               translate_to = thiscmd->translation[j] != TR_END ? thiscmd->translation[j] : TR_TEXT;
                        }
                        else
-                       {
-                               params.push_back(std::string(parameters[j]));
-                       }
+                               translate_to = TR_TEXT;
+
+                       ServerInstance->Log(DEBUG,"TRANSLATION: %s - type is %d", parameters[j], translate_to);
+                       ServerInstance->Parser->TranslateUIDs(translate_to, parameters[j], target);
+
+                       if (strchr(parameters[j],' '))
+                               params.push_back(":" + target);
+                       else
+                               params.push_back(target);
                }
                Utils->DoOneToMany(user->uuid, command, params);
        }
@@ -839,7 +850,7 @@ void ModuleSpanningTree::OnUserInvite(userrec* source,userrec* dest,chanrec* cha
        if (IS_LOCAL(source))
        {
                std::deque<std::string> params;
-               params.push_back(dest->nick);
+               params.push_back(dest->uuid);
                params.push_back(channel->name);
                Utils->DoOneToMany(source->uuid,"INVITE",params);
        }
@@ -872,7 +883,7 @@ void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type
                {
                        std::deque<std::string> params;
                        params.clear();
-                       params.push_back(d->nick);
+                       params.push_back(d->uuid);
                        params.push_back(":"+text);
                        Utils->DoOneToOne(user->uuid,"NOTICE",params,d->server);
                }
@@ -922,7 +933,7 @@ void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_typ
                {
                        std::deque<std::string> params;
                        params.clear();
-                       params.push_back(d->nick);
+                       params.push_back(d->uuid);
                        params.push_back(":"+text);
                        Utils->DoOneToOne(user->uuid,"PRIVMSG",params,d->server);
                }
@@ -981,11 +992,11 @@ void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel, bool &silen
                        params.push_back(channel->name);
                        params.push_back(ConvToStr(channel->age));
                        params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->uuid));
-                       Utils->DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params);
+                       Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FJOIN",params);
                        /* First user in, sync the modes for the channel */
                        params.pop_back();
                        params.push_back(channel->ChanModes(true));
-                       Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params);
+                       Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",params);
                }
                else
                {
@@ -1045,7 +1056,7 @@ void ModuleSpanningTree::OnUserConnect(userrec* user)
                params.push_back("+"+std::string(user->FormatModes()));
                params.push_back(user->GetIPString());
                params.push_back(":"+std::string(user->fullname));
-               Utils->DoOneToMany(ServerInstance->Config->ServerName, "UID", params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(), "UID", params);
                // User is Local, change needs to be reflected!
                TreeServer* SourceServer = Utils->FindServer(user->server);
                if (SourceServer)
@@ -1084,6 +1095,13 @@ void ModuleSpanningTree::OnUserPostNick(userrec* user, const std::string &oldnic
        {
                std::deque<std::string> params;
                params.push_back(user->nick);
+
+               /** IMPORTANT: We don't update the TS if the oldnick is just a case change of the newnick!
+                */
+               if (irc::string(user->nick) != assign(oldnick))
+                       user->age = ServerInstance->Time(true);
+
+               params.push_back(ConvToStr(user->age));
                Utils->DoOneToMany(user->uuid,"NICK",params);
        }
 }
@@ -1094,7 +1112,7 @@ void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* cha
        {
                std::deque<std::string> params;
                params.push_back(chan->name);
-               params.push_back(user->nick);
+               params.push_back(user->uuid);
                params.push_back(":"+reason);
                Utils->DoOneToMany(source->uuid,"KICK",params);
        }
@@ -1102,9 +1120,9 @@ void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* cha
        {
                std::deque<std::string> params;
                params.push_back(chan->name);
-               params.push_back(user->nick);
+               params.push_back(user->uuid);
                params.push_back(":"+reason);
-               Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"KICK",params);
        }
 }
 
@@ -1114,7 +1132,7 @@ void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std:
        params.push_back(":"+reason);
        Utils->DoOneToMany(dest->uuid,"OPERQUIT",params);
        params.clear();
-       params.push_back(dest->nick);
+       params.push_back(dest->uuid);
        params.push_back(":"+reason);
        dest->SetOperQuit(operreason);
        Utils->DoOneToMany(source->uuid,"KILL",params);
@@ -1126,7 +1144,7 @@ void ModuleSpanningTree::OnRehash(userrec* user, const std::string &parameter)
        {
                std::deque<std::string> params;
                params.push_back(parameter);
-               Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->ServerName, "REHASH", params);
+               Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->GetSID(), "REHASH", params);
                // check for self
                if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter))
                {
@@ -1161,7 +1179,7 @@ void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool a
                                (unsigned long)duration, reason.c_str());
                std::deque<std::string> params;
                params.push_back(data);
-               Utils->DoOneToMany(ServerInstance->Config->ServerName, "ADDLINE", params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(), "ADDLINE", params);
        }
        else
        {
@@ -1236,12 +1254,15 @@ void ModuleSpanningTree::OnMode(userrec* user, void* dest, int target_type, cons
        {
                std::deque<std::string> params;
                std::string command;
+               std::string output_text;
+
+               ServerInstance->Parser->TranslateUIDs(TR_SPACENICKLIST, text, output_text);
 
                if (target_type == TYPE_USER)
                {
                        userrec* u = (userrec*)dest;
-                       params.push_back(u->nick);
-                       params.push_back(text);
+                       params.push_back(u->uuid);
+                       params.push_back(output_text);
                        command = "MODE";
                }
                else
@@ -1249,9 +1270,10 @@ void ModuleSpanningTree::OnMode(userrec* user, void* dest, int target_type, cons
                        chanrec* c = (chanrec*)dest;
                        params.push_back(c->name);
                        params.push_back(ConvToStr(c->age));
-                       params.push_back(text);
+                       params.push_back(output_text);
                        command = "FMODE";
                }
+
                Utils->DoOneToMany(user->uuid, command, params);
        }
 }
@@ -1279,17 +1301,21 @@ void ModuleSpanningTree::OnCancelAway(userrec* user)
 void ModuleSpanningTree::ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline)
 {
        TreeSocket* s = (TreeSocket*)opaque;
+       std::string output_text;
+
+       ServerInstance->Parser->TranslateUIDs(TR_SPACENICKLIST, modeline, output_text);
+
        if (target)
        {
                if (target_type == TYPE_USER)
                {
                        userrec* u = (userrec*)target;
-                       s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline);
+                       s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" FMODE "+u->uuid+" "+ConvToStr(u->age)+" "+output_text);
                }
                else
                {
                        chanrec* c = (chanrec*)target;
-                       s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline);
+                       s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+output_text);
                }
        }
 }
@@ -1302,17 +1328,17 @@ void ModuleSpanningTree::ProtoSendMetaData(void* opaque, int target_type, void*
                if (target_type == TYPE_USER)
                {
                        userrec* u = (userrec*)target;
-                       s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+u->nick+" "+extname+" :"+extdata);
+                       s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+u->uuid+" "+extname+" :"+extdata);
                }
                else if (target_type == TYPE_CHANNEL)
                {
                        chanrec* c = (chanrec*)target;
-                       s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+c->name+" "+extname+" :"+extdata);
+                       s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+c->name+" "+extname+" :"+extdata);
                }
        }
        if (target_type == TYPE_OTHER)
        {
-               s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA * "+extname+" :"+extdata);
+               s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA * "+extname+" :"+extdata);
        }
 }
 
@@ -1324,7 +1350,7 @@ void ModuleSpanningTree::OnEvent(Event* event)
                if (params->size() < 3)
                        return;
                (*params)[2] = ":" + (*params)[2];
-               Utils->DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"METADATA",*params);
        }
        else if (event->GetEventID() == "send_topic")
        {
@@ -1333,7 +1359,7 @@ void ModuleSpanningTree::OnEvent(Event* event)
                (*params)[1] = ":" + (*params)[1];
                params->insert(params->begin() + 1,ServerInstance->Config->ServerName);
                params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time(true)));
-               Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FTOPIC",*params);
        }
        else if (event->GetEventID() == "send_mode")
        {
@@ -1341,11 +1367,17 @@ void ModuleSpanningTree::OnEvent(Event* event)
                        return;
                // Insert the TS value of the object, either userrec or chanrec
                time_t ourTS = 0;
+               std::string output_text;
+
+               /* Warning: in-place translation is only safe for type TR_NICK */
+               for (size_t n = 0; n < params->size(); n++)
+                       ServerInstance->Parser->TranslateUIDs(TR_NICK, (*params)[n], (*params)[n]);
+
                userrec* a = ServerInstance->FindNick((*params)[0]);
                if (a)
                {
                        ourTS = a->age;
-                       Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params);
+                       Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",*params);
                        return;
                }
                else
@@ -1355,7 +1387,7 @@ void ModuleSpanningTree::OnEvent(Event* event)
                        {
                                ourTS = a->age;
                                params->insert(params->begin() + 1,ConvToStr(ourTS));
-                               Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params);
+                               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",*params);
                        }
                }
        }
@@ -1363,28 +1395,34 @@ void ModuleSpanningTree::OnEvent(Event* event)
        {
                if (params->size() < 2)
                        return;
-               Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params);
+               std::string output_text;
+
+               /* Warning: in-place translation is only safe for type TR_NICK */
+               for (size_t n = 0; n < params->size(); n++)
+                       ServerInstance->Parser->TranslateUIDs(TR_NICK, (*params)[n], (*params)[n]);
+
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",*params);
        }
        else if (event->GetEventID() == "send_opers")
        {
                if (params->size() < 1)
                        return;
                (*params)[0] = ":" + (*params)[0];
-               Utils->DoOneToMany(ServerInstance->Config->ServerName,"OPERNOTICE",*params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"OPERNOTICE",*params);
        }
        else if (event->GetEventID() == "send_modeset")
        {
                if (params->size() < 2)
                        return;
                (*params)[1] = ":" + (*params)[1];
-               Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODENOTICE",*params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODENOTICE",*params);
        }
        else if (event->GetEventID() == "send_snoset")
        {
                if (params->size() < 2)
                        return;
                (*params)[1] = ":" + (*params)[1];
-               Utils->DoOneToMany(ServerInstance->Config->ServerName,"SNONOTICE",*params);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"SNONOTICE",*params);
        }
        else if (event->GetEventID() == "send_push")
        {
@@ -1395,9 +1433,10 @@ void ModuleSpanningTree::OnEvent(Event* event)
                        
                if (!a)
                        return;
-                       
+
+               (*params)[0] = a->uuid;
                (*params)[1] = ":" + (*params)[1];
-               Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", *params, a->server);
+               Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PUSH", *params, a->server);
        }
 }