Make User::uuid and User::server const

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

diff --git a/src/modules/m_spanningtree/postcommand.cpp b/src/modules/m_spanningtree/postcommand.cpp
index 1b1f618b8a2907d7bd5640322840b64c4d8f3009..c382bc874c259272de168e06cb92a2f1afd757bb 100644 (file)
--- a/src/modules/m_spanningtree/postcommand.cpp
+++ b/src/modules/m_spanningtree/postcommand.cpp
@@ -16,7 +16,6 @@
 #include "inspircd.h"
 #include "socket.h"
 #include "xline.h"
-#include "../transport.h"
 
 #include "main.h"
 #include "utils.h"
@@ -27,8 +26,12 @@
 
 void ModuleSpanningTree::OnPostCommand(const std::string &command, const std::vector<std::string>& parameters, User *user, CmdResult result, const std::string &original_line)
 {
-       if (result != CMD_SUCCESS)
-               return;
+       if (result == CMD_SUCCESS)
+               Utils->RouteCommand(NULL, command, parameters, user);
+}
+
+void SpanningTreeUtilities::RouteCommand(TreeServer* origin, const std::string &command, const parameterlist& parameters, User *user)
+{
        if (!ServerInstance->IsValidModuleCommand(command, parameters.size(), user))
                return;
 
@@ -42,7 +45,15 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const std::ve
 
        if (routing.type == ROUTE_TYPE_LOCALONLY)
        {
-               return;
+               Module* srcmodule = thiscmd->creator;
+               Version ver = srcmodule->GetVersion();
+
+               if ((ver.Flags & VF_CORE) && !IS_LOCAL(user))
+                       routing = ROUTE_BROADCAST;
+               else
+                       return;
+               if (IS_SERVER(user) && user != ServerInstance->FakeClient)
+                       return;
        }
        else if (routing.type == ROUTE_TYPE_OPT_BCAST)
        {
@@ -52,7 +63,7 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const std::ve
        }
        else if (routing.type == ROUTE_TYPE_OPT_UCAST)
        {
-               TreeServer* sdest = Utils->FindServer(routing.serverdest);
+               TreeServer* sdest = FindServer(routing.serverdest);
                if (!sdest)
                {
                        ServerInstance->Logs->Log("m_spanningtree",ERROR,"Trying to route ENCAP to nonexistant server %s",
@@ -68,7 +79,7 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const std::ve
                Module* srcmodule = thiscmd->creator;
                Version ver = srcmodule->GetVersion();
 
-               if (!(ver.Flags & VF_COMMON))
+               if (!(ver.Flags & (VF_COMMON | VF_CORE)))
                {
                        ServerInstance->Logs->Log("m_spanningtree",ERROR,"Routed command %s from non-VF_COMMON module %s",
                                command.c_str(), srcmodule->ModuleSourceFile.c_str());
@@ -81,8 +92,66 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const std::ve
 
        params.push_back(output_text);
 
-       if (routing.type == ROUTE_TYPE_BROADCAST || routing.type == ROUTE_TYPE_OPT_BCAST)
-               Utils->DoOneToMany(user->uuid, sent_cmd, params);
-       else
-               Utils->DoOneToOne(user->uuid, sent_cmd, params, routing.serverdest);
+       if (routing.type == ROUTE_TYPE_MESSAGE)
+       {
+               char pfx = 0;
+               std::string dest = routing.serverdest;
+               if (ServerInstance->Modes->FindPrefix(dest[0]))
+               {
+                       pfx = dest[0];
+                       dest = dest.substr(1);
+               }
+               if (dest[0] == '#')
+               {
+                       Channel* c = ServerInstance->FindChan(dest);
+                       if (!c)
+                               return;
+                       TreeServerList list;
+                       // TODO OnBuildExemptList hook was here
+                       GetListOfServersForChannel(c,list,pfx, CUList());
+                       std::string data = ":" + user->uuid + " " + sent_cmd;
+                       for (unsigned int x = 0; x < params.size(); x++)
+                               data += " " + params[x];
+                       for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
+                       {
+                               TreeSocket* Sock = i->second->GetSocket();
+                               if (origin && origin->GetSocket() == Sock)
+                                       continue;
+                               if (Sock)
+                                       Sock->WriteLine(data);
+                       }
+               }
+               else if (dest[0] == '$')
+               {
+                       if (origin)
+                               DoOneToAllButSender(user->uuid, sent_cmd, params, origin->GetName());
+                       else
+                               DoOneToMany(user->uuid, sent_cmd, params);
+               }
+               else
+               {
+                       // user target?
+                       User* d = ServerInstance->FindNick(dest);
+                       if (!d)
+                               return;
+                       TreeServer* tsd = BestRouteTo(d->server);
+                       if (tsd == origin)
+                               // huh? no routing stuff around in a circle, please.
+                               return;
+                       DoOneToOne(user->uuid, sent_cmd, params, d->server);
+               }
+       }
+       else if (routing.type == ROUTE_TYPE_BROADCAST || routing.type == ROUTE_TYPE_OPT_BCAST)
+       {
+               if (origin)
+                       DoOneToAllButSender(user->uuid, sent_cmd, params, origin->GetName());
+               else
+                       DoOneToMany(user->uuid, sent_cmd, params);
+       }
+       else if (routing.type == ROUTE_TYPE_UNICAST || routing.type == ROUTE_TYPE_OPT_UCAST)
+       {
+               if (origin && routing.serverdest == origin->GetName())
+                       return;
+               DoOneToOne(user->uuid, sent_cmd, params, routing.serverdest);
+       }
 }