Added remote rehash (even to a mask)

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

diff --git a/src/modules/m_spanningtree.cpp b/src/modules/m_spanningtree.cpp
index d63c11cbf0c4a84a9001b6b2007829fdb2337660..fa22f80a1555bd523e0328078845a33f21e23990 100644 (file)
--- a/src/modules/m_spanningtree.cpp
+++ b/src/modules/m_spanningtree.cpp
@@ -222,6 +222,11 @@ TreeServer* RouteEnumerate(TreeServer* Current, std::string ServerName)
 TreeServer* BestRouteTo(std::string ServerName)
 {
        log(DEBUG,"Finding best route to %s",ServerName.c_str());
+       if (ServerName.c_str() == TreeRoot->GetName())
+       {
+               log(DEBUG,"Cant route to myself!!!");
+               return NULL;
+       }
        // first, find the server by recursively walking the tree
        TreeServer* Found = RouteEnumerate(TreeRoot,ServerName);
        // did we find it? If not, they did something wrong, abort.
@@ -449,6 +454,36 @@ class TreeSocket : public InspSocket
                return true;
        }
 
+       bool ForceTopic(std::string source, std::deque<std::string> params)
+       {
+               // FTOPIC %s %lu %s :%s
+               if (params.size() != 4)
+                       return true;
+               std::string channel = params[0];
+               time_t ts = atoi(params[1].c_str());
+               std::string setby = params[2];
+               std::string topic = params[3];
+
+               chanrec* c = Srv->FindChannel(channel);
+               if (c)
+               {
+                       if ((ts >= c->topicset) || (!*c->topic))
+                       {
+                               strlcpy(c->topic,topic.c_str(),MAXTOPIC);
+                               strlcpy(c->setby,setby.c_str(),NICKMAX);
+                               c->topicset = ts;
+                               WriteChannelWithServ((char*)source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
+                       }
+                       
+               }
+               
+               // all done, send it on its way
+               params[3] = ":" + params[3];
+               DoOneToAllButSender(source,"FTOPIC",params,source);
+
+               return true;
+       }
+
        bool ForceJoin(std::string source, std::deque<std::string> params)
        {
                if (params.size() < 1)
@@ -526,10 +561,11 @@ class TreeSocket : public InspSocket
                if (iter != clientlist.end())
                {
                        // nick collision
-                       log(DEBUG,"Nick collision on %s!%s@%s",tempnick,ident.c_str(),host.c_str());
+                       log(DEBUG,"Nick collision on %s!%s@%s: %lu %lu",tempnick,ident.c_str(),host.c_str(),(unsigned long)age,(unsigned long)iter->second->age);
+                       this->WriteLine(":"+Srv->GetServerName()+" KILL "+tempnick+" :Nickname collision");
                        return true;
                }
-               
+
                clientlist[tempnick] = new userrec();
                clientlist[tempnick]->fd = FD_MAGIC_NUMBER;
                strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX);
@@ -546,6 +582,7 @@ class TreeSocket : public InspSocket
                        clientlist[tempnick]->chans[i].channel = NULL;
                        clientlist[tempnick]->chans[i].uc_modes = 0;
                }
+               params[7] = ":" + params[7];
                DoOneToAllButSender(source,"NICK",params,source);
                return true;
        }
@@ -669,6 +706,41 @@ class TreeSocket : public InspSocket
                return true;
        }
 
+       bool RemoteRehash(std::string prefix, std::deque<std::string> params)
+       {
+               if (params.size() < 1)
+                       return true;
+               std::string servermask = params[0];
+               if (Srv->MatchText(Srv->GetServerName(),servermask))
+               {
+                       Srv->RehashServer();
+               }
+               DoOneToAllButSender(prefix,"REHASH",params,prefix);
+               return;
+       }
+
+       bool RemoteKill(std::string prefix, std::deque<std::string> params)
+       {
+               if (params.size() != 2)
+                       return true;
+               std::string nick = params[0];
+               std::string reason = params[1];
+               userrec* u = Srv->FindNick(prefix);
+               userrec* who = Srv->FindNick(nick);
+               if (who)
+               {
+                       std::string sourceserv = prefix;
+                       if (u)
+                       {
+                               sourceserv = u->server;
+                       }
+                       params[1] = ":" + params[1];
+                       DoOneToAllButSender(prefix,"KILL",params,sourceserv);
+                       Srv->QuitUser(who,reason);
+               }
+               return true;
+       }
+
        bool RemoteServer(std::string prefix, std::deque<std::string> params)
        {
                if (params.size() < 4)
@@ -723,6 +795,7 @@ class TreeSocket : public InspSocket
                                // node.
                                TreeServer* Node = new TreeServer(servername,description,TreeRoot,this);
                                TreeRoot->AddChild(Node);
+                               params[3] = ":" + params[3];
                                DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
                                this->DoBurst(Node);
                                return true;
@@ -914,6 +987,18 @@ class TreeSocket : public InspSocket
                                {
                                        return this->ForceMode(prefix,params);
                                }
+                               else if (command == "KILL")
+                               {
+                                       return this->RemoteKill(prefix,params);
+                               }
+                               else if (command == "FTOPIC")
+                               {
+                                       return this->ForceTopic(prefix,params);
+                               }
+                               else if (command == "REHASH")
+                               {
+                                       return this->RemoteRehash(prefix,params);
+                               }
                                else if (command == "SQUIT")
                                {
                                        if (params.size() == 2)
@@ -1303,6 +1388,34 @@ class ModuleSpanningTree : public Module
                return 0;
        }
 
+       virtual void OnGetServerDescription(std::string servername,std::string &description)
+       {
+               TreeServer* s = FindServer(servername);
+               if (s)
+               {
+                       description = s->GetDesc();
+               }
+       }
+
+       virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel)
+       {
+               if (std::string(source->server) == Srv->GetServerName())
+               {
+                       std::deque<std::string> params;
+                       params.push_back(dest->nick);
+                       params.push_back(channel->name);
+                       DoOneToMany(source->nick,"INVITE",params);
+               }
+       }
+
+       virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic)
+       {
+               std::deque<std::string> params;
+               params.push_back(chan->name);
+               params.push_back(":"+topic);
+               DoOneToMany(user->nick,"TOPIC",params);
+       }
+
        virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text)
        {
                if (target_type == TYPE_USER)
@@ -1446,6 +1559,29 @@ class ModuleSpanningTree : public Module
                }
        }
 
+       virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason)
+       {
+               std::deque<std::string> params;
+               params.push_back(dest->nick);
+               params.push_back(":"+reason);
+               DoOneToMany(source->nick,"KILL",params);
+       }
+
+       virtual void OnRehash(std::string parameter)
+       {
+               if (parameter != "")
+               {
+                       std::deque<std::string> params;
+                       params.push_back(parameter);
+                       DoOneToMany(Srv->GetServerName(),"REHASH",params);
+                       // check for self
+                       if (Srv->MatchText(Srv->GetServerName(),parameter))
+                       {
+                               Srv->RehashServer();
+                       }
+               }
+       }
+
        // note: the protocol does not allow direct umode +o except
        // via NICK with 8 params. sending OPERTYPE infers +o modechange
        // locally.