X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree.cpp;h=3bf13d59afceb054232533909a1db3bf20acc583;hb=3f455b1747f822e867c37bc8902e51b5a36efba7;hp=7a409f759f6c074d12c467df012bad594fb4e64e;hpb=33887e4a65f3e5564204f052c0c145a6a9a8749b;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree.cpp b/src/modules/m_spanningtree.cpp index 7a409f759..3bf13d59a 100644 --- a/src/modules/m_spanningtree.cpp +++ b/src/modules/m_spanningtree.cpp @@ -16,8 +16,6 @@ /* $ModDesc: Povides a spanning tree server link protocol */ -using namespace std; - #include "configreader.h" #include "users.h" #include "channels.h" @@ -28,16 +26,12 @@ using namespace std; #include "inspircd.h" #include "wildcard.h" #include "xline.h" -#include "cull_list.h" #include "aes.h" -#define nspace __gnu_cxx - - /** If you make a change which breaks the protocol, increment this. * If you completely change the protocol, completely change the number. */ -const long ProtocolVersion = 1100; +const long ProtocolVersion = 1101; /* * The server list in InspIRCd is maintained as two structures @@ -58,15 +52,7 @@ const long ProtocolVersion = 1100; * any O(n) lookups. If however, during a split or sync, we want * to apply an operation to a server, and any of its child objects * we can resort to recursion to walk the tree structure. - */ - -using irc::sockets::MatchCIDR; - -class ModuleSpanningTree; -static ModuleSpanningTree* TreeProtocolModule; -static InspIRCd* ServerInstance; - -/* Any socket can have one of five states at any one time. + * Any socket can have one of five states at any one time. * The LISTENER state indicates a socket which is listening * for connections. It cannot receive data itself, only incoming * sockets. @@ -86,86 +72,129 @@ enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED }; /* Foward declarations */ class TreeServer; class TreeSocket; - -/* This variable represents the root of the server tree - * (for all intents and purposes, it's us) - */ -TreeServer *TreeRoot; +class Link; +class ModuleSpanningTree; /* This hash_map holds the hash equivalent of the server * tree, used for rapid linear lookups. */ typedef nspace::hash_map, irc::StrHashComp> server_hash; -server_hash serverlist; - -typedef nspace::hash_map uid_hash; -typedef nspace::hash_map sid_hash; - -/* More forward declarations */ -bool DoOneToOne(std::string prefix, std::string command, std::deque ¶ms, std::string target); -bool DoOneToAllButSender(std::string prefix, std::string command, std::deque ¶ms, std::string omit); -bool DoOneToAllButSender(const char* prefix, const char* command, std::deque ¶ms, std::string omit); -bool DoOneToMany(std::string prefix, std::string command, std::deque ¶ms); -bool DoOneToMany(const char* prefix, const char* command, std::deque ¶ms); -bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque ¶ms); -void ReadConfiguration(bool rebind); - -/* Flatten links and /MAP for non-opers */ -bool FlatLinks; -/* Hide U-Lined servers in /MAP and /LINKS */ -bool HideULines; -std::vector ValidIPs; -class UserManager : public classbase +/** The Link class might as well be a struct, + * but this is C++ and we don't believe in structs (!). + * It holds the entire information of one + * tag from the main config file. We maintain a list + * of them, and populate the list on rehash/load. + */ +class Link : public classbase { - uid_hash uids; - sid_hash sids; public: - UserManager() - { - uids.clear(); - sids.clear(); - } - - std::string UserToUID(userrec* user) - { - return ""; - } - - std::string UIDToUser(const std::string &UID) - { - return ""; - } - - std::string CreateAndAdd(userrec* user) - { - return ""; - } - - std::string CreateAndAdd(const std::string &servername) - { - return ""; - } - - std::string ServerToSID(const std::string &servername) - { - return ""; - } + irc::string Name; + std::string IPAddr; + int Port; + std::string SendPass; + std::string RecvPass; + unsigned long AutoConnect; + time_t NextConnectTime; + std::string EncryptionKey; + bool HiddenFromStats; + std::string FailOver; +}; - std::string SIDToServer(const std::string &SID) - { - return ""; - } +/** Contains helper functions and variables for this module, + * and keeps them out of the global namespace + */ +class SpanningTreeUtilities +{ + private: + /** Creator server + */ + InspIRCd* ServerInstance; + public: + /** Creator module + */ + ModuleSpanningTree* Creator; + /** Flatten links and /MAP for non-opers + */ + bool FlatLinks; + /** Hide U-Lined servers in /MAP and /LINKS + */ + bool HideULines; + /** Announce TS changes to channels on merge + */ + bool AnnounceTSChange; + /** Socket bindings for listening sockets + */ + std::vector Bindings; + /** This variable represents the root of the server tree + */ + TreeServer *TreeRoot; + /** IPs allowed to link to us + */ + std::vector ValidIPs; + /** Hash of currently connected servers by name + */ + server_hash serverlist; + /** Holds the data from the tags in the conf + */ + std::vector LinkBlocks; - userrec* FindByID(const std::string &UID) - { - return NULL; - } + /** Initialise utility class + */ + SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* Creator); + /** Destroy class and free listeners etc + */ + ~SpanningTreeUtilities(); + /** Send a message from this server to one other local or remote + */ + bool DoOneToOne(std::string prefix, std::string command, std::deque ¶ms, std::string target); + /** Send a message from this server to all but one other, local or remote + */ + bool DoOneToAllButSender(std::string prefix, std::string command, std::deque ¶ms, std::string omit); + /** Send a message from this server to all but one other, local or remote + */ + bool DoOneToAllButSender(const char* prefix, const char* command, std::deque ¶ms, std::string omit); + /** Send a message from this server to all others + */ + bool DoOneToMany(std::string prefix, std::string command, std::deque ¶ms); + /** Send a message from this server to all others + */ + bool DoOneToMany(const char* prefix, const char* command, std::deque ¶ms); + /** Send a message from this server to all others, without doing any processing on the command (e.g. send it as-is with colons and all) + */ + bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque ¶ms); + /** Read the spanningtree module's tags from the config file + */ + void ReadConfiguration(bool rebind); + /** Add a server to the server list for GetListOfServersForChannel + */ + void AddThisServer(TreeServer* server, std::deque &list); + /** Compile a list of servers which contain members of channel c + */ + void GetListOfServersForChannel(chanrec* c, std::deque &list); + /** Find a server by name + */ + TreeServer* FindServer(std::string ServerName); + /** Find a route to a server by name + */ + TreeServer* BestRouteTo(std::string ServerName); + /** Find a server by glob mask + */ + TreeServer* FindServerMask(std::string ServerName); + /** Returns true if this is a server name we recognise + */ + bool IsServer(std::string ServerName); + /** Attempt to connect to the failover link of link x + */ + void DoFailOver(Link* x); + /** Find a link tag from a server name + */ + Link* FindLink(const std::string& name); }; -/* Each server in the tree is represented by one class of +/** Each server in the tree is represented by one class of * type TreeServer. A locally connected TreeServer can * have a class of type TreeSocket associated with it, for * remote servers, the TreeSocket entry will be NULL. @@ -179,7 +208,6 @@ class UserManager : public classbase * TreeServer items, deleting and inserting them as they * are created and destroyed. */ - class TreeServer : public classbase { InspIRCd* ServerInstance; /* Creator */ @@ -194,13 +222,14 @@ class TreeServer : public classbase TreeSocket* Socket; /* For directly connected servers this points at the socket object */ time_t NextPing; /* After this time, the server should be PINGed*/ bool LastPingWasGood; /* True if the server responded to the last PING with a PONG */ + SpanningTreeUtilities* Utils; /* Utility class */ public: - /* We don't use this constructor. Its a dummy, and won't cause any insertion + /** We don't use this constructor. Its a dummy, and won't cause any insertion * of the TreeServer into the hash_map. See below for the two we DO use. */ - TreeServer(InspIRCd* Instance) : ServerInstance(Instance) + TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance) : ServerInstance(Instance), Utils(Util) { Parent = NULL; ServerName = ""; @@ -210,11 +239,11 @@ class TreeServer : public classbase VersionString = ServerInstance->GetVersionString(); } - /* We use this constructor only to create the 'root' item, TreeRoot, which + /** We use this constructor only to create the 'root' item, Utils->TreeRoot, which * represents our own server. Therefore, it has no route, no parent, and * no socket associated with it. Its version string is our own local version. */ - TreeServer(InspIRCd* Instance, std::string Name, std::string Desc) : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc) + TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc) : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc), Utils(Util) { Parent = NULL; VersionString = ""; @@ -225,12 +254,12 @@ class TreeServer : public classbase AddHashEntry(); } - /* When we create a new server, we call this constructor to initialize it. + /** When we create a new server, we call this constructor to initialize it. * This constructor initializes the server's Route and Parent, and sets up * its ping counters so that it will be pinged one minute from now. */ - TreeServer(InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) - : ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock) + TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) + : ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock), Utils(Util) { VersionString = ""; UserCount = OperCount = 0; @@ -262,13 +291,13 @@ class TreeServer : public classbase */ Route = Above; - if (Route == TreeRoot) + if (Route == Utils->TreeRoot) { Route = this; } else { - while (this->Route->GetParent() != TreeRoot) + while (this->Route->GetParent() != Utils->TreeRoot) { this->Route = Route->GetParent(); } @@ -313,34 +342,31 @@ class TreeServer : public classbase return time_to_die.size(); } - /* This method is used to add the structure to the + /** This method is used to add the structure to the * hash_map for linear searches. It is only called * by the constructors. */ void AddHashEntry() { - server_hash::iterator iter; - iter = serverlist.find(this->ServerName.c_str()); - if (iter == serverlist.end()) - serverlist[this->ServerName.c_str()] = this; + server_hash::iterator iter = Utils->serverlist.find(this->ServerName.c_str()); + if (iter == Utils->serverlist.end()) + Utils->serverlist[this->ServerName.c_str()] = this; } - /* This method removes the reference to this object + /** This method removes the reference to this object * from the hash_map which is used for linear searches. * It is only called by the default destructor. */ void DelHashEntry() { - server_hash::iterator iter; - iter = serverlist.find(this->ServerName.c_str()); - if (iter != serverlist.end()) - serverlist.erase(iter); + server_hash::iterator iter = Utils->serverlist.find(this->ServerName.c_str()); + if (iter != Utils->serverlist.end()) + Utils->serverlist.erase(iter); } - /* These accessors etc should be pretty self- + /** These accessors etc should be pretty self- * explanitory. */ - TreeServer* GetRoute() { return Route; @@ -457,7 +483,7 @@ class TreeServer : public classbase return false; } - /* Removes child nodes of this node, and of that node, etc etc. + /** Removes child nodes of this node, and of that node, etc etc. * This is used during netsplits to automatically tidy up the * server tree. It is slow, we don't use it for much else. */ @@ -487,46 +513,13 @@ class TreeServer : public classbase } }; -/* The Link class might as well be a struct, - * but this is C++ and we don't believe in structs (!). - * It holds the entire information of one - * tag from the main config file. We maintain a list - * of them, and populate the list on rehash/load. - */ - -class Link : public classbase -{ - public: - irc::string Name; - std::string IPAddr; - int Port; - std::string SendPass; - std::string RecvPass; - unsigned long AutoConnect; - time_t NextConnectTime; - std::string EncryptionKey; - bool HiddenFromStats; - irc::string FailOver; -}; - -void DoFailOver(Link* x); -Link* FindLink(const std::string& name); - -/* The usual stuff for inspircd modules, - * plus the vector of Link classes which we - * use to store the tags from the config - * file. - */ -ConfigReader *Conf; -std::vector LinkBlocks; - -/* Yay for fast searches! +/** Yay for fast searches! * This is hundreds of times faster than recursion * or even scanning a linked list, especially when * there are more than a few servers to deal with. * (read as: lots). */ -TreeServer* FindServer(std::string ServerName) +TreeServer* SpanningTreeUtilities::FindServer(std::string ServerName) { server_hash::iterator iter; iter = serverlist.find(ServerName.c_str()); @@ -540,13 +533,13 @@ TreeServer* FindServer(std::string ServerName) } } -/* Returns the locally connected server we must route a +/** Returns the locally connected server we must route a * message through to reach server 'ServerName'. This * only applies to one-to-one and not one-to-many routing. * See the comments for the constructor of TreeServer * for more details. */ -TreeServer* BestRouteTo(std::string ServerName) +TreeServer* SpanningTreeUtilities::BestRouteTo(std::string ServerName) { if (ServerName.c_str() == TreeRoot->GetName()) return NULL; @@ -561,13 +554,13 @@ TreeServer* BestRouteTo(std::string ServerName) } } -/* Find the first server matching a given glob mask. +/** Find the first server matching a given glob mask. * Theres no find-using-glob method of hash_map [awwww :-(] * so instead, we iterate over the list using an iterator * and match each one until we get a hit. Yes its slow, * deal with it. */ -TreeServer* FindServerMask(std::string ServerName) +TreeServer* SpanningTreeUtilities::FindServerMask(std::string ServerName) { for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++) { @@ -578,17 +571,20 @@ TreeServer* FindServerMask(std::string ServerName) } /* A convenient wrapper that returns true if a server exists */ -bool IsServer(std::string ServerName) +bool SpanningTreeUtilities::IsServer(std::string ServerName) { return (FindServer(ServerName) != NULL); } +/** Handle /RCONNECT + */ class cmd_rconnect : public command_t { Module* Creator; + SpanningTreeUtilities* Utils; public: - cmd_rconnect (InspIRCd* Instance, Module* Callback) : command_t(Instance, "RCONNECT", 'o', 2), Creator(Callback) + cmd_rconnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : command_t(Instance, "RCONNECT", 'o', 2), Creator(Callback), Utils(Util) { this->source = "m_spanningtree.so"; syntax = " "; @@ -604,7 +600,8 @@ class cmd_rconnect : public command_t ServerInstance->SNO->WriteToSnoMask('l',"Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick,parameters[0],parameters[1]); const char* para[1]; para[0] = parameters[1]; - Creator->OnPreCommand("CONNECT", para, 1, user, true); + std::string original_command = std::string("CONNECT ") + parameters[1]; + Creator->OnPreCommand("CONNECT", para, 1, user, true, original_command); return CMD_SUCCESS; } @@ -615,7 +612,7 @@ class cmd_rconnect : public command_t -/* Every SERVER connection inbound or outbound is represented by +/** Every SERVER connection inbound or outbound is represented by * an object of type TreeSocket. * TreeSockets, being inherited from InspSocket, can be tied into * the core socket engine, and we cn therefore receive activity events @@ -626,9 +623,9 @@ class cmd_rconnect : public command_t * maintain a list of servers, some of which are directly connected, * some of which are not. */ - class TreeSocket : public InspSocket { + SpanningTreeUtilities* Utils; std::string myhost; std::string in_buffer; ServerState LinkState; @@ -647,13 +644,13 @@ class TreeSocket : public InspSocket public: - /* Because most of the I/O gubbins are encapsulated within + /** Because most of the I/O gubbins are encapsulated within * InspSocket, we just call the superclass constructor for * most of the action, and append a few of our own values * to it. */ - TreeSocket(InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime) - : InspSocket(SI, host, port, listening, maxtime) + TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime) + : InspSocket(SI, host, port, listening, maxtime), Utils(Util) { myhost = host; this->LinkState = LISTENER; @@ -661,8 +658,8 @@ class TreeSocket : public InspSocket this->ctx_out = NULL; } - TreeSocket(InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, std::string ServerName) - : InspSocket(SI, host, port, listening, maxtime) + TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, std::string ServerName) + : InspSocket(SI, host, port, listening, maxtime), Utils(Util) { myhost = ServerName; this->LinkState = CONNECTING; @@ -670,12 +667,12 @@ class TreeSocket : public InspSocket this->ctx_out = NULL; } - /* When a listening socket gives us a new file descriptor, + /** When a listening socket gives us a new file descriptor, * we must associate it with a socket without creating a new * connection. This constructor is used for this purpose. */ - TreeSocket(InspIRCd* SI, int newfd, char* ip) - : InspSocket(SI, newfd, ip) + TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip) + : InspSocket(SI, newfd, ip), Utils(Util) { this->LinkState = WAIT_AUTH_1; this->ctx_in = NULL; @@ -708,15 +705,18 @@ class TreeSocket : public InspSocket } else { - this->Instance->SNO->WriteToSnoMask('l',"\2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str()); - ctx_in->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ - \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength); - ctx_out->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ - \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength); + if (this->GetState() != I_ERROR) + { + this->Instance->SNO->WriteToSnoMask('l',"\2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str()); + ctx_in->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ + \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength); + ctx_out->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ + \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength); + } } } - /* When an outbound connection finishes connecting, we receive + /** When an outbound connection finishes connecting, we receive * this event, and must send our SERVER string to the other * side. If the other side is happy, as outlined in the server * to server docs on the inspircd.org site, the other side @@ -727,11 +727,11 @@ class TreeSocket : public InspSocket if (this->LinkState == CONNECTING) { /* we do not need to change state here. */ - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if (x->Name == this->myhost) { - this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] established."); + this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] started."); this->SendCapabilities(); if (x->EncryptionKey != "") { @@ -769,9 +769,9 @@ class TreeSocket : public InspSocket if (e == I_ERR_CONNECT) { this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused"); - Link* MyLink = FindLink(myhost); + Link* MyLink = Utils->FindLink(myhost); if (MyLink) - DoFailOver(MyLink); + Utils->DoFailOver(MyLink); } } @@ -783,7 +783,7 @@ class TreeSocket : public InspSocket return true; } - /* Recursively send the server tree with distances as hops. + /** Recursively send the server tree with distances as hops. * This is used during network burst to inform the other server * (and any of ITS servers too) of what servers we know about. * If at any point any of these servers already exist on the other @@ -1026,7 +1026,7 @@ class TreeSocket : public InspSocket return true; } - /* This function forces this server to quit, removing this server + /** This function forces this server to quit, removing this server * and any users on it (and servers and users below that, etc etc). * It's very slow and pretty clunky, but luckily unless your network * is having a REAL bad hair day, this function shouldnt be called @@ -1048,19 +1048,19 @@ class TreeSocket : public InspSocket num_lost_users += Current->QuitUsers(from); } - /* This is a wrapper function for SquitServer above, which + /** This is a wrapper function for SquitServer above, which * does some validation first and passes on the SQUIT to all * other remaining servers. */ void Squit(TreeServer* Current,std::string reason) { - if ((Current) && (Current != TreeRoot)) + if ((Current) && (Current != Utils->TreeRoot)) { std::deque params; params.push_back(Current->GetName()); params.push_back(":"+reason); - DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName()); - if (Current->GetParent() == TreeRoot) + Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName()); + if (Current->GetParent() == Utils->TreeRoot) { this->Instance->WriteOpers("Server \002"+Current->GetName()+"\002 split: "+reason); } @@ -1083,7 +1083,7 @@ class TreeSocket : public InspSocket } } - /* FMODE command - server mode with timestamp checks */ + /** FMODE command - server mode with timestamp checks */ bool ForceMode(std::string source, std::deque ¶ms) { /* Chances are this is a 1.0 FMODE without TS */ @@ -1147,6 +1147,9 @@ class TreeSocket : public InspSocket { ourTS = chan->age; } + else + /* Oops, channel doesnt exist! */ + return true; } /* TS is equal: Merge the mode changes, use voooodoooooo on modes @@ -1299,7 +1302,7 @@ class TreeSocket : public InspSocket newparams.push_back(ConvToStr(ourTS)); newparams.push_back(to_bounce+params_to_bounce); Instance->Log(DEBUG,"BOUNCE BACK: %s",(to_bounce+params_to_bounce).c_str()); - DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv); + Utils->DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv); } if (to_keep.length()) @@ -1309,7 +1312,7 @@ class TreeSocket : public InspSocket modelist[0] = params[0].c_str(); modelist[1] = to_keep.c_str(); - if (params_to_keep.size() > 1) + if (params_to_keep.size() > 0) { for (q = 0; (q < params_to_keep.size()) && (q < 64); q++) { @@ -1321,16 +1324,16 @@ class TreeSocket : public InspSocket if (smode) { Instance->Log(DEBUG,"Send mode"); - this->Instance->SendMode(modelist, n+2, who); + this->Instance->SendMode(modelist, n, who); } else { Instance->Log(DEBUG,"Send mode client"); - this->Instance->CallCommandHandler("MODE", modelist, n+2, who); + this->Instance->CallCommandHandler("MODE", modelist, n, who); } /* HOT POTATO! PASS IT ON! */ - DoOneToAllButSender(source,"FMODE",params,sourceserv); + Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv); } } else @@ -1439,7 +1442,7 @@ class TreeSocket : public InspSocket /* Update the parameters for FMODE with the new 'bounced' string */ newparams[2] = modebounce; /* Only send it back the way it came, no need to send it anywhere else */ - DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv); + Utils->DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv); Instance->Log(DEBUG,"FMODE bounced intelligently, our TS less than theirs and the other server is NOT a uline."); } else @@ -1459,7 +1462,7 @@ class TreeSocket : public InspSocket this->Instance->CallCommandHandler("MODE", modelist, n, who); /* HOT POTATO! PASS IT ON! */ - DoOneToAllButSender(source,"FMODE",params,sourceserv); + Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv); } /* Are we supposed to free the userrec? */ if (smode) @@ -1468,7 +1471,7 @@ class TreeSocket : public InspSocket return true; } - /* FTOPIC command */ + /** FTOPIC command */ bool ForceTopic(std::string source, std::deque ¶ms) { if (params.size() != 4) @@ -1503,7 +1506,7 @@ class TreeSocket : public InspSocket } /* all done, send it on its way */ params[3] = ":" + params[3]; - DoOneToAllButSender(source,"FTOPIC",params,nsource); + Utils->DoOneToAllButSender(source,"FTOPIC",params,nsource); } } @@ -1512,45 +1515,109 @@ class TreeSocket : public InspSocket return true; } - /* FJOIN, similar to unreal SJOIN */ + /** FJOIN, similar to TS6 SJOIN, but not quite. */ bool ForceJoin(std::string source, std::deque ¶ms) { + /* 1.1 FJOIN works as follows: + * + * Each FJOIN is sent along with a timestamp, and the side with the lowest + * timestamp 'wins'. From this point on we will refer to this side as the + * winner. The side with the higher timestamp loses, from this point on we + * will call this side the loser or losing side. This should be familiar to + * anyone who's dealt with dreamforge or TS6 before. + * + * When two sides of a split heal and this occurs, the following things + * will happen: + * + * If the timestamps are exactly equal, both sides merge their privilages + * and users, as in InspIRCd 1.0 and ircd2.8. The channels have not been + * re-created during a split, this is safe to do. + * + * + * If the timestamps are NOT equal, the losing side removes all privilage + * modes from all of its users that currently exist in the channel, before + * introducing new users into the channel which are listed in the FJOIN + * command's parameters. This means, all modes +ohv, and privilages added + * by modules, such as +qa. The losing side then LOWERS its timestamp value + * of the channel to match that of the winning side, and the modes of the + * users of the winning side are merged in with the losing side. The loser + * then sends out a set of FMODE commands which 'confirm' that it just + * removed all privilage modes from its existing users, which allows for + * services packages to still work correctly without needing to know the + * timestamping rules which InspIRCd follows. In TS6 servers this is always + * a problem, and services packages must contain code which explicitly + * behaves as TS6 does, removing ops from the losing side of a split where + * neccessary within its internal records, as this state information is + * not explicitly echoed out in that protocol. + * + * The winning side on the other hand will ignore all user modes from the + * losing side, so only its own modes get applied. Life is simple for those + * who succeed at internets. :-) + * + * NOTE: Unlike TS6 and dreamforge and other protocols which have SJOIN, + * FJOIN does not contain the simple-modes such as +iklmnsp. Why not, + * you ask? Well, quite simply because we don't need to. They'll be sent + * after the FJOIN by FMODE, and FMODE is timestamped, so in the event + * the losing side sends any modes for the channel which shouldnt win, + * they wont as their timestamp will be too high :-) + */ + if (params.size() < 3) return true; - char first[MAXBUF]; - char modestring[MAXBUF]; - char* mode_users[127]; - memset(&mode_users,0,sizeof(mode_users)); - mode_users[0] = first; - mode_users[1] = modestring; - strcpy(modestring,"+"); - unsigned int modectr = 2; + char first[MAXBUF]; /* The first parameter of the mode command */ + char modestring[MAXBUF]; /* The mode sequence (2nd parameter) of the mode command */ + char* mode_users[127]; /* The values used by the mode command */ + memset(&mode_users,0,sizeof(mode_users)); /* Initialize mode parameters */ + mode_users[0] = first; /* Set this up to be our on-stack value */ + mode_users[1] = modestring; /* Same here as above */ + strcpy(modestring,"+"); /* Initialize the mode sequence to just '+' */ + unsigned int modectr = 2; /* Pointer to the third mode parameter (e.g. the one after the +-sequence) */ - userrec* who = NULL; - std::string channel = params[0]; - time_t TS = atoi(params[1].c_str()); - char* key = ""; + userrec* who = NULL; /* User we are currently checking */ + std::string channel = params[0]; /* Channel name, as a string */ + time_t TS = atoi(params[1].c_str()); /* Timestamp given to us for remote side */ + /* Try and find the channel */ chanrec* chan = this->Instance->FindChan(channel); - if (chan) - { - key = chan->key; - } + + /* Initialize channel name in the mode parameters */ strlcpy(mode_users[0],channel.c_str(),MAXBUF); - /* default is a high value, which if we dont have this + /* default TS is a high value, which if we dont have this * channel will let the other side apply their modes. */ time_t ourTS = time(NULL)+600; - chanrec* us = this->Instance->FindChan(channel); - if (us) + + /* Does this channel exist? if it does, get its REAL timestamp */ + if (chan) + ourTS = chan->age; + + /* In 1.1, if they have the newer channel, we immediately clear + * all status modes from our users. We then accept their modes. + * If WE have the newer channel its the other side's job to do this. + * Note that this causes the losing server to send out confirming + * FMODE lines. + */ + if (ourTS > TS) { - ourTS = us->age; - } + std::deque param_list; - Instance->Log(DEBUG,"FJOIN detected, our TS=%lu, their TS=%lu",ourTS,TS); + if (chan) + chan->age = TS; + /* Lower the TS here */ + if (Utils->AnnounceTSChange && chan) + chan->WriteChannelWithServ(Instance->Config->ServerName, + "TS for %s changed from %lu to %lu", chan->name, ourTS, TS); + ourTS = TS; + + param_list.push_back(channel); + /* Zap all the privilage modes on our side */ + this->RemoveStatus(Instance->Config->ServerName, param_list); + } + + /* Put the final parameter of the FJOIN into a tokenstream ready to split it */ irc::tokenstream users(params[2]); std::string item = "*"; @@ -1558,81 +1625,121 @@ class TreeSocket : public InspSocket * if there is a TS collision. */ params[2] = ":" + params[2]; - DoOneToAllButSender(source,"FJOIN",params,source); + Utils->DoOneToAllButSender(source,"FJOIN",params,source); + + /* Now, process every 'prefixes,nick' pair */ while (item != "") { + /* Find next user */ item = users.GetToken(); - /* process one user at a time, applying modes. */ - char* usr = (char*)item.c_str(); + + const char* usr = item.c_str(); + /* Safety check just to make sure someones not sent us an FJOIN full of spaces * (is this even possible?) */ if (usr && *usr) { - char* permissions = usr; + const char* permissions = usr; int ntimes = 0; - while ((*permissions) && (*permissions != ',')) + char* nm = new char[MAXBUF]; + char* tnm = nm; + + /* Iterate through all the prefix values, convert them from prefixes + * to mode letters, and append them to the mode sequence + */ + while ((*permissions) && (*permissions != ',') && (ntimes < MAXBUF)) { ModeHandler* mh = Instance->Modes->FindPrefix(*permissions); if (mh) { + /* This is a valid prefix */ ntimes++; - charlcat(modestring,mh->GetModeChar(),MAXBUF); + *tnm++ = mh->GetModeChar(); } else { - this->Instance->WriteOpers("ERROR: We received a user with an unknown prefix '%c'. Closed connection to avoid a desync.",mh->GetPrefix()); - this->WriteLine(std::string("ERROR :Invalid prefix '")+mh->GetModeChar()+"' in FJOIN"); + /* Not a valid prefix... + * danger bill bobbertson! (that's will robinsons older brother ;-) ...) + */ + this->Instance->WriteOpers("ERROR: We received a user with an unknown prefix '%c'. Closed connection to avoid a desync.",*permissions); + this->WriteLine(std::string("ERROR :Invalid prefix '")+(*permissions)+"' in FJOIN"); return false; } usr++; permissions++; } - usr++; - /* Did they get any modes? How many times? */ - for (int k = 0; k < ntimes; k++) - mode_users[modectr++] = strdup(usr); + /* Null terminate modes */ + *tnm = 0; + /* Advance past the comma, to the nick */ + usr++; + /* Check the user actually exists */ who = this->Instance->FindNick(usr); if (who) { - chanrec::JoinUser(this->Instance, who, channel.c_str(), true, key); + /* Did they get any modes? How many times? */ + strlcat(modestring, nm, MAXBUF); + for (int k = 0; k < ntimes; k++) + mode_users[modectr++] = strdup(usr); + + /* Free temporary buffer used for mode sequence */ + delete[] nm; + + /* Check that the user's 'direction' is correct + * based on the server sending the FJOIN. We must + * check each nickname in turn, because the origin of + * the FJOIN may be different to the origin of the nicks + * in the command itself. + */ + TreeServer* route_back_again = Utils->BestRouteTo(who->server); + if ((!route_back_again) || (route_back_again->GetSocket() != this)) + { + /* Oh dear oh dear. */ + Instance->Log(DEBUG,"Fake direction in FJOIN, user '%s'",who->nick); + continue; + } + /* Finally, we can actually place the user into the channel. + * We're sure its right. Final answer, phone a friend. + */ + chanrec::JoinUser(this->Instance, who, channel.c_str(), true, ""); + + /* Have we already queued up MAXMODES modes with parameters + * (+qaohv) ready to be sent to the server? + */ if (modectr >= (MAXMODES-1)) { - /* theres a mode for this user. push them onto the mode queue, and flush it - * if there are more than MAXMODES to go. + /* Only actually give the users any status if we lost + * the FJOIN or drew (equal timestamps). + * It isn't actually possible for ourTS to be > TS here, + * only possible to actually have ourTS == TS, or + * ourTS < TS, because if we lost, we already lowered + * our TS above before we entered this loop. We only + * check >= as a safety measure, in case someone stuffed + * up. If someone DID stuff up, it was most likely me. + * Note: I do not like baseball bats in the face... */ - if ((ourTS >= TS) || (this->Instance->ULine(who->server))) + if (ourTS >= TS) { - /* We also always let u-lined clients win, no matter what the TS value */ Instance->Log(DEBUG,"Our our channel newer than theirs, accepting their modes"); this->Instance->SendMode((const char**)mode_users,modectr,who); - if (ourTS != TS) + + /* Something stuffed up, and for some reason, the timestamp is + * NOT lowered right now and should be. Lower it. Usually this + * code won't be executed, doubtless someone will remove it some + * day soon. + */ + if (ourTS > TS) { - Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us->name,ourTS,TS); - us->age = TS; + Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",chan->name,ourTS,TS); + chan->age = TS; ourTS = TS; } } - else - { - Instance->Log(DEBUG,"Their channel newer than ours, bouncing their modes"); - /* bouncy bouncy! */ - std::deque params; - /* modes are now being UNSET... */ - *mode_users[1] = '-'; - for (unsigned int x = 0; x < modectr; x++) - { - if (x == 1) - { - params.push_back(ConvToStr(us->age)); - } - params.push_back(mode_users[x]); - - } - // tell everyone to bounce the modes. bad modes, bad! - DoOneToMany(this->Instance->Config->ServerName,"FMODE",params); - } + + /* Reset all this back to defaults, and + * free any ram we have left allocated. + */ strcpy(mode_users[1],"+"); for (unsigned int f = 2; f < modectr; f++) free(mode_users[f]); @@ -1641,50 +1748,52 @@ class TreeSocket : public InspSocket } else { - Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", who->nick, channel.c_str()); + /* Remember to free this */ + delete[] nm; + /* If we got here, there's a nick in FJOIN which doesnt exist on this server. + * We don't try to process the nickname here (that WOULD cause a segfault because + * we'd be playing with null pointers) however, we DO pass the nickname on, just + * in case somehow we're desynched, so that other users which might be able to see + * the nickname get their fair chance to process it. + */ + Instance->Log(SPARSE,"Warning! Invalid user in FJOIN to channel %s IGNORED", channel.c_str()); continue; } } } + /* there werent enough modes built up to flush it during FJOIN, * or, there are a number left over. flush them out. */ - if ((modectr > 2) && (who) && (us)) + if ((modectr > 2) && (who) && (chan)) { if (ourTS >= TS) { - Instance->Log(DEBUG,"Our our channel newer than theirs, accepting their modes"); + /* Our channel is newer than theirs. Evil deeds must be afoot. */ this->Instance->SendMode((const char**)mode_users,modectr,who); - if (ourTS != TS) + /* Yet again, we can't actually get a true value here, if everything else + * is working as it should. + */ + if (ourTS > TS) { - Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us->name,ourTS,TS); - us->age = TS; + Instance->Log(DEFAULT,"Channel TS for %s changed from %lu to %lu",chan->name,ourTS,TS); + chan->age = TS; ourTS = TS; } } - else - { - Instance->Log(DEBUG,"Their channel newer than ours, bouncing their modes"); - std::deque params; - *mode_users[1] = '-'; - for (unsigned int x = 0; x < modectr; x++) - { - if (x == 1) - { - params.push_back(ConvToStr(us->age)); - } - params.push_back(mode_users[x]); - } - DoOneToMany(this->Instance->Config->ServerName,"FMODE",params); - } + /* Free anything we have left to free */ for (unsigned int f = 2; f < modectr; f++) free(mode_users[f]); } + + /* All done. That wasnt so bad was it, you can wipe + * the sweat from your forehead now. :-) + */ return true; } - /* NICK command */ + /** NICK command */ bool IntroduceClient(std::string source, std::deque ¶ms) { if (params.size() < 8) @@ -1715,6 +1824,7 @@ class TreeSocket : public InspSocket // nick collision Instance->Log(DEBUG,"Nick collision on %s!%s@%s: %lu %lu",tempnick,params[4].c_str(),params[2].c_str(),(unsigned long)age,(unsigned long)iter->second->age); this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+tempnick+" :Nickname collision"); + userrec::QuitUser(this->Instance, iter->second, "Nickname collision"); return true; } @@ -1743,20 +1853,22 @@ class TreeSocket : public InspSocket this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString()); params[7] = ":" + params[7]; - DoOneToAllButSender(source,"NICK",params,source); + Utils->DoOneToAllButSender(source,"NICK",params,source); // Increment the Source Servers User Count.. - TreeServer* SourceServer = FindServer(source); + TreeServer* SourceServer = Utils->FindServer(source); if (SourceServer) { Instance->Log(DEBUG,"Found source server of %s",_new->nick); SourceServer->AddUserCount(); } + FOREACH_MOD_I(Instance,I_OnPostConnect,OnPostConnect(_new)); + return true; } - /* Send one or more FJOINs for a channel of users. + /** Send one or more FJOINs for a channel of users. * If the length of a single line is more than 480-NICKMAX * in length, it is split over multiple lines. */ @@ -1808,7 +1920,7 @@ class TreeSocket : public InspSocket this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" +"+c->ChanModes(true)+modes+" "+params); } - /* Send G, Q, Z and E lines */ + /** Send G, Q, Z and E lines */ void SendXLines(TreeServer* Current) { char data[MAXBUF]; @@ -1816,49 +1928,49 @@ class TreeSocket : public InspSocket const char* sn = n.c_str(); int iterations = 0; /* Yes, these arent too nice looking, but they get the job done */ - for (std::vector::iterator i = Instance->XLines->zlines.begin(); i != Instance->XLines->zlines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->zlines.begin(); i != Instance->XLines->zlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } - for (std::vector::iterator i = Instance->XLines->qlines.begin(); i != Instance->XLines->qlines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->qlines.begin(); i != Instance->XLines->qlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } - for (std::vector::iterator i = Instance->XLines->glines.begin(); i != Instance->XLines->glines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->glines.begin(); i != Instance->XLines->glines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } - for (std::vector::iterator i = Instance->XLines->elines.begin(); i != Instance->XLines->elines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->elines.begin(); i != Instance->XLines->elines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } - for (std::vector::iterator i = Instance->XLines->pzlines.begin(); i != Instance->XLines->pzlines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->pzlines.begin(); i != Instance->XLines->pzlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } - for (std::vector::iterator i = Instance->XLines->pqlines.begin(); i != Instance->XLines->pqlines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->pqlines.begin(); i != Instance->XLines->pqlines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } - for (std::vector::iterator i = Instance->XLines->pglines.begin(); i != Instance->XLines->pglines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->pglines.begin(); i != Instance->XLines->pglines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } - for (std::vector::iterator i = Instance->XLines->pelines.begin(); i != Instance->XLines->pelines.end(); i++, iterations++) + for (std::vector::iterator i = Instance->XLines->pelines.begin(); i != Instance->XLines->pelines.end(); i++, iterations++) { - snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason); + snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); this->WriteLine(data); } } - /* Send channel modes and topics */ + /** Send channel modes and topics */ void SendChannelModes(TreeServer* Current) { char data[MAXBUF]; @@ -1874,17 +1986,17 @@ class TreeSocket : public InspSocket snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",sn,c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic); this->WriteLine(data); } - FOREACH_MOD_I(this->Instance,I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this)); + FOREACH_MOD_I(this->Instance,I_OnSyncChannel,OnSyncChannel(c->second,(Module*)Utils->Creator,(void*)this)); list.clear(); c->second->GetExtList(list); for (unsigned int j = 0; j < list.size(); j++) { - FOREACH_MOD_I(this->Instance,I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)TreeProtocolModule,(void*)this,list[j])); + FOREACH_MOD_I(this->Instance,I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)Utils->Creator,(void*)this,list[j])); } } } - /* send all users and their oper state/modes */ + /** send all users and their oper state/modes */ void SendUsers(TreeServer* Current) { char data[MAXBUF]; @@ -1904,18 +2016,18 @@ class TreeSocket : public InspSocket { this->WriteLine(":"+std::string(u->second->nick)+" AWAY :"+std::string(u->second->awaymsg)); } - FOREACH_MOD_I(this->Instance,I_OnSyncUser,OnSyncUser(u->second,(Module*)TreeProtocolModule,(void*)this)); + FOREACH_MOD_I(this->Instance,I_OnSyncUser,OnSyncUser(u->second,(Module*)Utils->Creator,(void*)this)); list.clear(); u->second->GetExtList(list); for (unsigned int j = 0; j < list.size(); j++) { - FOREACH_MOD_I(this->Instance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)TreeProtocolModule,(void*)this,list[j])); + FOREACH_MOD_I(this->Instance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)Utils->Creator,(void*)this,list[j])); } } } } - /* This function is called when we want to send a netburst to a local + /** This function is called when we want to send a netburst to a local * server. There is a set order we must do this, because for example * users require their servers to exist, and channels require their * users to exist. You get the idea. @@ -1931,18 +2043,18 @@ class TreeSocket : public InspSocket /* send our version string */ this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" VERSION :"+this->Instance->GetVersionString()); /* Send server tree */ - this->SendServers(TreeRoot,s,1); + this->SendServers(Utils->TreeRoot,s,1); /* Send users and their oper status */ this->SendUsers(s); /* Send everything else (channel modes, xlines etc) */ this->SendChannelModes(s); this->SendXLines(s); - FOREACH_MOD_I(this->Instance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this)); + FOREACH_MOD_I(this->Instance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)Utils->Creator,(void*)this)); this->WriteLine(endburst); this->Instance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+name+"\2."); } - /* This function is called when we receive data from a remote + /** This function is called when we receive data from a remote * server. We buffer the data in a std::string (it doesnt stay * there for long), reading using InspSocket::Read() which can * read up to 16 kilobytes in one operation. @@ -1975,14 +2087,12 @@ class TreeSocket : public InspSocket char result[1024]; memset(result,0,1024); memset(out,0,1024); - Instance->Log(DEBUG,"Original string '%s'",ret.c_str()); /* ERROR + CAPAB is still allowed unencryped */ if ((ret.substr(0,7) != "ERROR :") && (ret.substr(0,6) != "CAPAB ")) { int nbytes = from64tobits(out, ret.c_str(), 1024); if ((nbytes > 0) && (nbytes < 1024)) { - Instance->Log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes); ctx_in->Decrypt(out, result, nbytes, 0); for (int t = 0; t < nbytes; t++) if (result[t] == '\7') result[t] = 0; @@ -2016,16 +2126,12 @@ class TreeSocket : public InspSocket // pad it to the key length int n = this->keylength - (line.length() % this->keylength); if (n) - { - Instance->Log(DEBUG,"Append %d chars to line to make it %d long from %d, key length %d",n,n+line.length(),line.length(),this->keylength); line.append(n,'\7'); - } } unsigned int ll = line.length(); ctx_out->Encrypt(line.c_str(), result, ll, 0); to64frombits((unsigned char*)result64,(unsigned char*)result,ll); line = result64; - //int from64tobits(char *out, const char *in, int maxlen); } return this->Write(line + "\r\n"); } @@ -2040,7 +2146,7 @@ class TreeSocket : public InspSocket return false; } - /* remote MOTD. leet, huh? */ + /** remote MOTD. leet, huh? */ bool Motd(std::string prefix, std::deque ¶ms) { if (params.size() > 0) @@ -2060,21 +2166,21 @@ class TreeSocket : public InspSocket if (!Instance->Config->MOTD.size()) { par[1] = std::string("::")+Instance->Config->ServerName+" 422 "+source->nick+" :Message of the day file is missing."; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); return true; } par[1] = std::string("::")+Instance->Config->ServerName+" 375 "+source->nick+" :"+Instance->Config->ServerName+" message of the day"; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); for (unsigned int i = 0; i < Instance->Config->MOTD.size(); i++) { par[1] = std::string("::")+Instance->Config->ServerName+" 372 "+source->nick+" :- "+Instance->Config->MOTD[i]; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } par[1] = std::string("::")+Instance->Config->ServerName+" 376 "+source->nick+" End of message of the day."; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } else @@ -2082,13 +2188,13 @@ class TreeSocket : public InspSocket /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) - DoOneToOne(prefix, "MOTD", params, params[0]); + Utils->DoOneToOne(prefix, "MOTD", params, params[0]); } } return true; } - /* remote ADMIN. leet, huh? */ + /** remote ADMIN. leet, huh? */ bool Admin(std::string prefix, std::deque ¶ms) { if (params.size() > 0) @@ -2106,16 +2212,16 @@ class TreeSocket : public InspSocket par.push_back(""); par[1] = std::string("::")+Instance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+Instance->Config->ServerName; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 257 "+source->nick+" :Name - "+Instance->Config->AdminName; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :Nickname - "+Instance->Config->AdminNick; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :E-Mail - "+Instance->Config->AdminEmail; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } else @@ -2123,7 +2229,7 @@ class TreeSocket : public InspSocket /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) - DoOneToOne(prefix, "ADMIN", params, params[0]); + Utils->DoOneToOne(prefix, "ADMIN", params, params[0]); } } return true; @@ -2150,7 +2256,7 @@ class TreeSocket : public InspSocket for (size_t i = 0; i < results.size(); i++) { par[1] = "::" + results[i]; - DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } } @@ -2159,14 +2265,14 @@ class TreeSocket : public InspSocket /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) - DoOneToOne(prefix, "STATS", params, params[1]); + Utils->DoOneToOne(prefix, "STATS", params, params[1]); } } return true; } - /* Because the core won't let users or even SERVERS set +o, + /** Because the core won't let users or even SERVERS set +o, * we use the OPERTYPE command to do this. */ bool OperType(std::string prefix, std::deque ¶ms) @@ -2182,12 +2288,12 @@ class TreeSocket : public InspSocket { u->modes[UM_OPERATOR] = 1; strlcpy(u->oper,opertype.c_str(),NICKMAX-1); - DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server); + Utils->DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server); } return true; } - /* Because Andy insists that services-compatible servers must + /** Because Andy insists that services-compatible servers must * implement SVSNICK and SVSJOIN, that's exactly what we do :p */ bool ForceNick(std::string prefix, std::deque ¶ms) @@ -2199,14 +2305,14 @@ class TreeSocket : public InspSocket if (u) { - DoOneToAllButSender(prefix,"SVSNICK",params,prefix); + Utils->DoOneToAllButSender(prefix,"SVSNICK",params,prefix); if (IS_LOCAL(u)) { std::deque par; par.push_back(params[1]); /* This is not required as one is sent in OnUserPostNick below */ - //DoOneToMany(u->nick,"NICK",par); + //Utils->DoOneToMany(u->nick,"NICK",par); if (!u->ForceNickChange(params[1].c_str())) { userrec::QuitUser(this->Instance, u, "Nickname collision"); @@ -2228,7 +2334,7 @@ class TreeSocket : public InspSocket if (u) { chanrec::JoinUser(this->Instance, u, params[1].c_str(), false); - DoOneToAllButSender(prefix,"SVSJOIN",params,prefix); + Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix); } return true; } @@ -2244,9 +2350,10 @@ class TreeSocket : public InspSocket { this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated from server \002"+prefix+"\002."); this->Instance->RehashServer(); - ReadConfiguration(false); + Utils->ReadConfiguration(false); + InitializeDisabledCommands(Instance->Config->DisabledCommands, Instance); } - DoOneToAllButSender(prefix,"REHASH",params,prefix); + Utils->DoOneToAllButSender(prefix,"REHASH",params,prefix); return true; } @@ -2273,7 +2380,7 @@ class TreeSocket : public InspSocket } std::string reason = params[1]; params[1] = ":" + params[1]; - DoOneToAllButSender(prefix,"KILL",params,sourceserv); + Utils->DoOneToAllButSender(prefix,"KILL",params,sourceserv); who->Write(":%s KILL %s :%s (%s)", sourceserv.c_str(), who->nick, sourceserv.c_str(), reason.c_str()); userrec::QuitUser(this->Instance,who,reason); } @@ -2287,7 +2394,7 @@ class TreeSocket : public InspSocket if (params.size() == 1) { - TreeServer* ServerSource = FindServer(prefix); + TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { ServerSource->SetPingFlag(); @@ -2314,7 +2421,7 @@ class TreeSocket : public InspSocket else { // not for us, pass it on :) - DoOneToOne(prefix,"PONG",params,forwardto); + Utils->DoOneToOne(prefix,"PONG",params,forwardto); } } @@ -2326,7 +2433,7 @@ class TreeSocket : public InspSocket if (params.size() < 3) return true; - TreeServer* ServerSource = FindServer(prefix); + TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { @@ -2353,7 +2460,7 @@ class TreeSocket : public InspSocket } params[2] = ":" + params[2]; - DoOneToAllButSender(prefix,"METADATA",params,prefix); + Utils->DoOneToAllButSender(prefix,"METADATA",params,prefix); return true; } @@ -2362,14 +2469,14 @@ class TreeSocket : public InspSocket if (params.size() < 1) return true; - TreeServer* ServerSource = FindServer(prefix); + TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { ServerSource->SetVersion(params[0]); } params[0] = ":" + params[0]; - DoOneToAllButSender(prefix,"VERSION",params,prefix); + Utils->DoOneToAllButSender(prefix,"VERSION",params,prefix); return true; } @@ -2383,7 +2490,7 @@ class TreeSocket : public InspSocket if (u) { u->ChangeDisplayedHost(params[0].c_str()); - DoOneToAllButSender(prefix,"FHOST",params,u->server); + Utils->DoOneToAllButSender(prefix,"FHOST",params,u->server); } return true; } @@ -2435,7 +2542,7 @@ class TreeSocket : public InspSocket this->Instance->SNO->WriteToSnoMask('x',"%s Added permenant %cLINE on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),params[5].c_str()); } params[5] = ":" + params[5]; - DoOneToAllButSender(prefix,"ADDLINE",params,prefix); + Utils->DoOneToAllButSender(prefix,"ADDLINE",params,prefix); } if (!this->bursting) { @@ -2456,7 +2563,7 @@ class TreeSocket : public InspSocket { u->ChangeName(params[0].c_str()); params[0] = ":" + params[0]; - DoOneToAllButSender(prefix,"FNAME",params,u->server); + Utils->DoOneToAllButSender(prefix,"FNAME",params,u->server); } return true; } @@ -2489,12 +2596,12 @@ class TreeSocket : public InspSocket par.push_back(signon); par.push_back(idle); // ours, we're done, pass it BACK - DoOneToOne(params[0],"IDLE",par,u->server); + Utils->DoOneToOne(params[0],"IDLE",par,u->server); } else { // not ours pass it on - DoOneToOne(prefix,"IDLE",params,x->server); + Utils->DoOneToOne(prefix,"IDLE",params,x->server); } } else if (params.size() == 3) @@ -2513,7 +2620,7 @@ class TreeSocket : public InspSocket else { // not ours, pass it on - DoOneToOne(prefix,"IDLE",params,who_to_send_to->server); + Utils->DoOneToOne(prefix,"IDLE",params,who_to_send_to->server); } } } @@ -2538,7 +2645,7 @@ class TreeSocket : public InspSocket { // continue the raw onwards params[1] = ":" + params[1]; - DoOneToOne(prefix,"PUSH",params,u->server); + Utils->DoOneToOne(prefix,"PUSH",params,u->server); } return true; } @@ -2559,7 +2666,7 @@ class TreeSocket : public InspSocket snprintf(curtime,256,"%lu",(unsigned long)time(NULL)); params.push_back(curtime); params[0] = prefix; - DoOneToOne(this->Instance->Config->ServerName,"TIME",params,params[0]); + Utils->DoOneToOne(this->Instance->Config->ServerName,"TIME",params,params[0]); } } else @@ -2567,7 +2674,7 @@ class TreeSocket : public InspSocket // not us, pass it on userrec* u = this->Instance->FindNick(params[1]); if (u) - DoOneToOne(prefix,"TIME",params,params[0]); + Utils->DoOneToOne(prefix,"TIME",params,params[0]); } } else if (params.size() == 3) @@ -2587,7 +2694,7 @@ class TreeSocket : public InspSocket else { if (u) - DoOneToOne(prefix,"TIME",params,u->server); + Utils->DoOneToOne(prefix,"TIME",params,u->server); } } return true; @@ -2612,17 +2719,75 @@ class TreeSocket : public InspSocket // this is a ping for us, send back PONG to the requesting server params[1] = params[0]; params[0] = forwardto; - DoOneToOne(forwardto,"PONG",params,params[1]); + Utils->DoOneToOne(forwardto,"PONG",params,params[1]); } else { // not for us, pass it on :) - DoOneToOne(prefix,"PING",params,forwardto); + Utils->DoOneToOne(prefix,"PING",params,forwardto); } return true; } } + bool RemoveStatus(std::string prefix, std::deque ¶ms) + { + if (params.size() < 1) + return true; + + chanrec* c = Instance->FindChan(params[0]); + + if (c) + { + irc::modestacker modestack(false); + CUList *ulist = c->GetUsers(); + const char* y[127]; + std::deque stackresult; + std::string x; + + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + { + std::string modesequence = Instance->Modes->ModeString(i->second, c); + if (modesequence.length()) + { + Instance->Log(DEBUG,"Mode sequence = '%s'",modesequence.c_str()); + irc::spacesepstream sep(modesequence); + std::string modeletters = sep.GetToken(); + Instance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str()); + + while (!modeletters.empty()) + { + char mletter = *(modeletters.begin()); + modestack.Push(mletter,sep.GetToken()); + Instance->Log(DEBUG,"Push letter = '%c'",mletter); + modeletters.erase(modeletters.begin()); + Instance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str()); + } + } + } + + while (modestack.GetStackedLine(stackresult)) + { + Instance->Log(DEBUG,"Stacked line size %d",stackresult.size()); + stackresult.push_front(ConvToStr(c->age)); + stackresult.push_front(c->name); + Utils->DoOneToMany(Instance->Config->ServerName, "FMODE", stackresult); + stackresult.erase(stackresult.begin() + 1); + Instance->Log(DEBUG,"Stacked items:"); + for (size_t z = 0; z < stackresult.size(); z++) + { + y[z] = stackresult[z].c_str(); + Instance->Log(DEBUG,"\tstackresult[%d]='%s'",z,stackresult[z].c_str()); + } + userrec* n = new userrec(Instance); + n->SetFd(FD_MAGIC_NUMBER); + Instance->SendMode(y, stackresult.size(), n); + delete n; + } + } + return true; + } + bool RemoteServer(std::string prefix, std::deque ¶ms) { if (params.size() < 4) @@ -2632,24 +2797,24 @@ class TreeSocket : public InspSocket std::string password = params[1]; // hopcount is not used for a remote server, we calculate this ourselves std::string description = params[3]; - TreeServer* ParentOfThis = FindServer(prefix); + TreeServer* ParentOfThis = Utils->FindServer(prefix); if (!ParentOfThis) { this->WriteLine("ERROR :Protocol error - Introduced remote server from unknown server "+prefix); return false; } - TreeServer* CheckDupe = FindServer(servername); + TreeServer* CheckDupe = Utils->FindServer(servername); if (CheckDupe) { this->WriteLine("ERROR :Server "+servername+" already exists!"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+servername+"\2 denied, already exists"); return false; } - TreeServer* Node = new TreeServer(this->Instance,servername,description,ParentOfThis,NULL); + TreeServer* Node = new TreeServer(this->Utils,this->Instance,servername,description,ParentOfThis,NULL); ParentOfThis->AddChild(Node); params[3] = ":" + params[3]; - DoOneToAllButSender(prefix,"SERVER",params,prefix); + Utils->DoOneToAllButSender(prefix,"SERVER",params,prefix); this->Instance->SNO->WriteToSnoMask('l',"Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")"); return true; } @@ -2671,11 +2836,11 @@ class TreeSocket : public InspSocket return false; } std::string description = params[3]; - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->Name == servername) && (x->RecvPass == password)) { - TreeServer* CheckDupe = FindServer(sname); + TreeServer* CheckDupe = Utils->FindServer(sname); if (CheckDupe) { this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); @@ -2690,10 +2855,10 @@ class TreeSocket : public InspSocket // we should add the details of this server now // to the servers tree, as a child of the root // node. - TreeServer* Node = new TreeServer(this->Instance,sname,description,TreeRoot,this); - TreeRoot->AddChild(Node); + TreeServer* Node = new TreeServer(this->Utils,this->Instance,sname,description,Utils->TreeRoot,this); + Utils->TreeRoot->AddChild(Node); params[3] = ":" + params[3]; - DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,sname); + Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,sname); this->bursting = true; this->DoBurst(Node); return true; @@ -2721,11 +2886,11 @@ class TreeSocket : public InspSocket return false; } std::string description = params[3]; - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->Name == servername) && (x->RecvPass == password)) { - TreeServer* CheckDupe = FindServer(sname); + TreeServer* CheckDupe = Utils->FindServer(sname); if (CheckDupe) { this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); @@ -2795,7 +2960,7 @@ class TreeSocket : public InspSocket if ((!this->ctx_in) && (command == "AES")) { std::string sserv = params[0]; - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->EncryptionKey != "") && (x->Name == sserv)) { @@ -2848,7 +3013,9 @@ class TreeSocket : public InspSocket } else { - this->WriteLine("ERROR :Invalid command in negotiation phase."); + std::string error("ERROR :Invalid command in negotiation phase: "); + error.append(command.c_str()); + this->WriteLine(error); return false; } break; @@ -2885,14 +3052,14 @@ class TreeSocket : public InspSocket } } this->LinkState = CONNECTED; - Node = new TreeServer(this->Instance,InboundServerName,InboundDescription,TreeRoot,this); - TreeRoot->AddChild(Node); + Node = new TreeServer(this->Utils,this->Instance,InboundServerName,InboundDescription,Utils->TreeRoot,this); + Utils->TreeRoot->AddChild(Node); params.clear(); params.push_back(InboundServerName); params.push_back("*"); params.push_back("1"); params.push_back(":"+InboundDescription); - DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName); + Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,InboundServerName); this->bursting = true; this->DoBurst(Node); } @@ -2938,7 +3105,7 @@ class TreeSocket : public InspSocket { direction = t->server; } - TreeServer* route_back_again = BestRouteTo(direction); + TreeServer* route_back_again = Utils->BestRouteTo(direction); if ((!route_back_again) || (route_back_again->GetSocket() != this)) { if (route_back_again) @@ -3018,6 +3185,10 @@ class TreeSocket : public InspSocket { return this->MetaData(prefix,params); } + else if (command == "REMSTATUS") + { + return this->RemoveStatus(prefix,params); + } else if (command == "PING") { /* @@ -3090,7 +3261,7 @@ class TreeSocket : public InspSocket { return this->Time(prefix,params); } - else if ((command == "KICK") && (IsServer(prefix))) + else if ((command == "KICK") && (Utils->IsServer(prefix))) { std::string sourceserv = this->myhost; if (params.size() == 3) @@ -3108,7 +3279,7 @@ class TreeSocket : public InspSocket { sourceserv = this->InboundServerName; } - return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } else if (command == "SVSJOIN") { @@ -3122,7 +3293,7 @@ class TreeSocket : public InspSocket { if (params.size() == 2) { - this->Squit(FindServer(params[0]),params[1]); + this->Squit(Utils->FindServer(params[0]),params[1]); } return true; } @@ -3163,18 +3334,18 @@ class TreeSocket : public InspSocket std::deque p; p.push_back(params[0]); p.push_back("Nickname collision ("+prefix+" -> "+params[0]+")"); - DoOneToMany(this->Instance->Config->ServerName,"KILL",p); + Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p); p.clear(); p.push_back(prefix); p.push_back("Nickname collision"); - DoOneToMany(this->Instance->Config->ServerName,"KILL",p); + Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p); userrec::QuitUser(this->Instance,x,"Nickname collision ("+prefix+" -> "+params[0]+")"); userrec* y = this->Instance->FindNick(prefix); if (y) { userrec::QuitUser(this->Instance,y,"Nickname collision"); } - return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } } // its a user @@ -3201,7 +3372,7 @@ class TreeSocket : public InspSocket else { // its not a user. Its either a server, or somethings screwed up. - if (IsServer(prefix)) + if (Utils->IsServer(prefix)) { target = this->Instance->Config->ServerName; } @@ -3211,7 +3382,7 @@ class TreeSocket : public InspSocket return true; } } - return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } return true; @@ -3235,9 +3406,9 @@ class TreeSocket : public InspSocket if (this->LinkState == CONNECTING) { this->Instance->SNO->WriteToSnoMask('l',"CONNECT: Connection to \002"+myhost+"\002 timed out."); - Link* MyLink = FindLink(myhost); + Link* MyLink = Utils->FindLink(myhost); if (MyLink) - DoFailOver(MyLink); + Utils->DoFailOver(MyLink); } } @@ -3251,7 +3422,7 @@ class TreeSocket : public InspSocket { quitserver = this->InboundServerName; } - TreeServer* s = FindServer(quitserver); + TreeServer* s = Utils->FindServer(quitserver); if (s) { Squit(s,"Remote host closed the connection"); @@ -3267,11 +3438,11 @@ class TreeSocket : public InspSocket */ bool found = false; - found = (std::find(ValidIPs.begin(), ValidIPs.end(), ip) != ValidIPs.end()); + found = (std::find(Utils->ValidIPs.begin(), Utils->ValidIPs.end(), ip) != Utils->ValidIPs.end()); if (!found) { - for (vector::iterator i = ValidIPs.begin(); i != ValidIPs.end(); i++) - if (MatchCIDR(ip, (*i).c_str())) + for (vector::iterator i = Utils->ValidIPs.begin(); i != Utils->ValidIPs.end(); i++) + if (irc::sockets::MatchCIDR(ip, (*i).c_str())) found = true; if (!found) @@ -3281,7 +3452,7 @@ class TreeSocket : public InspSocket return false; } } - TreeSocket* s = new TreeSocket(this->Instance, newsock, ip); + TreeSocket* s = new TreeSocket(this->Utils, this->Instance, newsock, ip); s = s; /* Whinge whinge whinge, thats all GCC ever does. */ return true; } @@ -3301,8 +3472,9 @@ class ServernameResolver : public Resolver * admin takes the tag away and rehashes while the domain is resolving. */ Link MyLink; + SpanningTreeUtilities* Utils; public: - ServernameResolver(InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD), MyLink(x) + ServernameResolver(SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD), MyLink(x), Utils(Util) { /* Nothing in here, folks */ } @@ -3313,10 +3485,10 @@ class ServernameResolver : public Resolver * Passing a hostname directly to InspSocket causes it to * just bail and set its FD to -1. */ - TreeServer* CheckDupe = FindServer(MyLink.Name.c_str()); + TreeServer* CheckDupe = Utils->FindServer(MyLink.Name.c_str()); if (!CheckDupe) /* Check that nobody tried to connect it successfully while we were resolving */ { - TreeSocket* newsocket = new TreeSocket(ServerInstance, result,MyLink.Port,false,10,MyLink.Name.c_str()); + TreeSocket* newsocket = new TreeSocket(this->Utils, ServerInstance, result,MyLink.Port,false,10,MyLink.Name.c_str()); if (newsocket->GetFd() > -1) { /* We're all OK */ @@ -3326,7 +3498,7 @@ class ServernameResolver : public Resolver /* Something barfed, show the opers */ ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",MyLink.Name.c_str(),strerror(errno)); delete newsocket; - DoFailOver(&MyLink); + Utils->DoFailOver(&MyLink); } } } @@ -3335,23 +3507,26 @@ class ServernameResolver : public Resolver { /* Ooops! */ ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: Unable to resolve hostname - %s",MyLink.Name.c_str(),errormessage.c_str()); - DoFailOver(&MyLink); + Utils->DoFailOver(&MyLink); } }; +/** Handle resolving of server IPs for the cache + */ class SecurityIPResolver : public Resolver { private: Link MyLink; + SpanningTreeUtilities* Utils; public: - SecurityIPResolver(InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD), MyLink(x) + SecurityIPResolver(SpanningTreeUtilities* U, InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD), MyLink(x), Utils(U) { } void OnLookupComplete(const std::string &result) { ServerInstance->Log(DEBUG,"Security IP cache: Adding IP address '%s' for Link '%s'",result.c_str(),MyLink.Name.c_str()); - ValidIPs.push_back(result); + Utils->ValidIPs.push_back(result); } void OnError(ResolverError e, const std::string &errormessage) @@ -3360,7 +3535,39 @@ class SecurityIPResolver : public Resolver } }; -void AddThisServer(TreeServer* server, std::deque &list) +SpanningTreeUtilities::SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* C) : ServerInstance(Instance), Creator(C) +{ + Bindings.clear(); + this->ReadConfiguration(true); + this->TreeRoot = new TreeServer(this, ServerInstance, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc); +} + +SpanningTreeUtilities::~SpanningTreeUtilities() +{ + for (unsigned int i = 0; i < Bindings.size(); i++) + { + ServerInstance->Log(DEBUG,"Freeing binding %d of %d",i, Bindings.size()); + ServerInstance->SE->DelFd(Bindings[i]); + Bindings[i]->Close(); + DELETE(Bindings[i]); + } + ServerInstance->Log(DEBUG,"Freeing connected servers..."); + while (TreeRoot->ChildCount()) + { + TreeServer* child_server = TreeRoot->GetChild(0); + ServerInstance->Log(DEBUG,"Freeing connected server %s", child_server->GetName().c_str()); + if (child_server) + { + TreeSocket* sock = child_server->GetSocket(); + ServerInstance->SE->DelFd(sock); + sock->Close(); + DELETE(sock); + } + } + delete TreeRoot; +} + +void SpanningTreeUtilities::AddThisServer(TreeServer* server, std::deque &list) { for (unsigned int c = 0; c < list.size(); c++) { @@ -3372,15 +3579,15 @@ void AddThisServer(TreeServer* server, std::deque &list) list.push_back(server); } -// returns a list of DIRECT servernames for a specific channel -void GetListOfServersForChannel(chanrec* c, std::deque &list) +/** returns a list of DIRECT servernames for a specific channel */ +void SpanningTreeUtilities::GetListOfServersForChannel(chanrec* c, std::deque &list) { CUList *ulist = c->GetUsers(); for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { if (i->second->GetFd() < 0) { - TreeServer* best = BestRouteTo(i->second->server); + TreeServer* best = this->BestRouteTo(i->second->server); if (best) AddThisServer(best,list); } @@ -3388,9 +3595,9 @@ void GetListOfServersForChannel(chanrec* c, std::deque &list) return; } -bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque ¶ms) +bool SpanningTreeUtilities::DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque ¶ms) { - TreeServer* omitroute = BestRouteTo(omit); + TreeServer* omitroute = this->BestRouteTo(omit); if ((command == "NOTICE") || (command == "PRIVMSG")) { if (params.size() >= 2) @@ -3409,7 +3616,7 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref std::deque par; par.push_back(params[0]); par.push_back(":"+params[1]); - DoOneToOne(prefix,command.c_str(),par,d->server); + this->DoOneToOne(prefix,command.c_str(),par,d->server); return true; } } @@ -3418,25 +3625,22 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref std::deque par; par.push_back(params[0]); par.push_back(":"+params[1]); - DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName()); + this->DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName()); return true; } else { - ServerInstance->Log(DEBUG,"Channel privmsg going to chan %s",params[0].c_str()); chanrec* c = ServerInstance->FindChan(params[0]); if (c) { std::deque list; GetListOfServersForChannel(c,list); - ServerInstance->Log(DEBUG,"Got a list of %d servers",list.size()); unsigned int lsize = list.size(); for (unsigned int i = 0; i < lsize; i++) { TreeSocket* Sock = list[i]->GetSocket(); if ((Sock) && (list[i]->GetName() != omit) && (omitroute != list[i])) { - ServerInstance->Log(DEBUG,"Writing privmsg to server %s",list[i]->GetName().c_str()); Sock->WriteLine(data); } } @@ -3445,10 +3649,10 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref } } } - unsigned int items = TreeRoot->ChildCount(); + unsigned int items =this->TreeRoot->ChildCount(); for (unsigned int x = 0; x < items; x++) { - TreeServer* Route = TreeRoot->GetChild(x); + TreeServer* Route = this->TreeRoot->GetChild(x); if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route)) { TreeSocket* Sock = Route->GetSocket(); @@ -3459,19 +3663,19 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref return true; } -bool DoOneToAllButSender(std::string prefix, std::string command, std::deque ¶ms, std::string omit) +bool SpanningTreeUtilities::DoOneToAllButSender(std::string prefix, std::string command, std::deque ¶ms, std::string omit) { - TreeServer* omitroute = BestRouteTo(omit); + TreeServer* omitroute = this->BestRouteTo(omit); std::string FullLine = ":" + prefix + " " + command; unsigned int words = params.size(); for (unsigned int x = 0; x < words; x++) { FullLine = FullLine + " " + params[x]; } - unsigned int items = TreeRoot->ChildCount(); + unsigned int items = this->TreeRoot->ChildCount(); for (unsigned int x = 0; x < items; x++) { - TreeServer* Route = TreeRoot->GetChild(x); + TreeServer* Route = this->TreeRoot->GetChild(x); // Send the line IF: // The route has a socket (its a direct connection) // The route isnt the one to be omitted @@ -3486,7 +3690,7 @@ bool DoOneToAllButSender(std::string prefix, std::string command, std::deque ¶ms) +bool SpanningTreeUtilities::DoOneToMany(std::string prefix, std::string command, std::deque ¶ms) { std::string FullLine = ":" + prefix + " " + command; unsigned int words = params.size(); @@ -3494,10 +3698,10 @@ bool DoOneToMany(std::string prefix, std::string command, std::dequeChildCount(); + unsigned int items = this->TreeRoot->ChildCount(); for (unsigned int x = 0; x < items; x++) { - TreeServer* Route = TreeRoot->GetChild(x); + TreeServer* Route = this->TreeRoot->GetChild(x); if (Route && Route->GetSocket()) { TreeSocket* Sock = Route->GetSocket(); @@ -3508,23 +3712,23 @@ bool DoOneToMany(std::string prefix, std::string command, std::deque ¶ms) +bool SpanningTreeUtilities::DoOneToMany(const char* prefix, const char* command, std::deque ¶ms) { std::string spfx = prefix; std::string scmd = command; - return DoOneToMany(spfx, scmd, params); + return this->DoOneToMany(spfx, scmd, params); } -bool DoOneToAllButSender(const char* prefix, const char* command, std::deque ¶ms, std::string omit) +bool SpanningTreeUtilities::DoOneToAllButSender(const char* prefix, const char* command, std::deque ¶ms, std::string omit) { std::string spfx = prefix; std::string scmd = command; - return DoOneToAllButSender(spfx, scmd, params, omit); + return this->DoOneToAllButSender(spfx, scmd, params, omit); } - -bool DoOneToOne(std::string prefix, std::string command, std::deque ¶ms, std::string target) + +bool SpanningTreeUtilities::DoOneToOne(std::string prefix, std::string command, std::deque ¶ms, std::string target) { - TreeServer* Route = BestRouteTo(target); + TreeServer* Route = this->BestRouteTo(target); if (Route) { std::string FullLine = ":" + prefix + " " + command; @@ -3547,27 +3751,27 @@ bool DoOneToOne(std::string prefix, std::string command, std::deque } } -std::vector Bindings; - -void ReadConfiguration(bool rebind) +void SpanningTreeUtilities::ReadConfiguration(bool rebind) { - Conf = new ConfigReader(ServerInstance); + ConfigReader* Conf = new ConfigReader(ServerInstance); if (rebind) { for (int j =0; j < Conf->Enumerate("bind"); j++) { std::string Type = Conf->ReadValue("bind","type",j); std::string IP = Conf->ReadValue("bind","address",j); - long Port = Conf->ReadInteger("bind","port",j,true); + int Port = Conf->ReadInteger("bind","port",j,true); if (Type == "servers") { + ServerInstance->Log(DEBUG,"m_spanningtree: Binding server port %s:%d", IP.c_str(), Port); if (IP == "*") { IP = ""; } - TreeSocket* listener = new TreeSocket(ServerInstance, IP.c_str(),Port,true,10); + TreeSocket* listener = new TreeSocket(this, ServerInstance, IP.c_str(),Port,true,10); if (listener->GetState() == I_LISTENING) { + ServerInstance->Log(DEFAULT,"m_spanningtree: Binding server port %s:%d successful!", IP.c_str(), Port); Bindings.push_back(listener); } else @@ -3576,11 +3780,13 @@ void ReadConfiguration(bool rebind) listener->Close(); DELETE(listener); } + ServerInstance->Log(DEBUG,"Done with this binding"); } } } FlatLinks = Conf->ReadFlag("options","flatlinks",0); HideULines = Conf->ReadFlag("options","hideulines",0); + AnnounceTSChange = Conf->ReadFlag("options","announcets",0); LinkBlocks.clear(); ValidIPs.clear(); for (int j =0; j < Conf->Enumerate("link"); j++) @@ -3613,7 +3819,7 @@ void ReadConfiguration(bool rebind) { try { - SecurityIPResolver* sr = new SecurityIPResolver(ServerInstance, L.IPAddr, L); + SecurityIPResolver* sr = new SecurityIPResolver(this, ServerInstance, L.IPAddr, L); ServerInstance->AddResolver(sr); } catch (ModuleException& e) @@ -3658,44 +3864,37 @@ void ReadConfiguration(bool rebind) } + class ModuleSpanningTree : public Module { - std::vector Bindings; int line; int NumServers; unsigned int max_local; unsigned int max_global; cmd_rconnect* command_rconnect; + SpanningTreeUtilities* Utils; public: ModuleSpanningTree(InspIRCd* Me) : Module::Module(Me), max_local(0), max_global(0) { - - Bindings.clear(); - - ::ServerInstance = Me; - - // Create the root of the tree - TreeRoot = new TreeServer(ServerInstance, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc); - - ReadConfiguration(true); + Utils = new SpanningTreeUtilities(Me, this); - command_rconnect = new cmd_rconnect(ServerInstance, this); + command_rconnect = new cmd_rconnect(ServerInstance, this, Utils); ServerInstance->AddCommand(command_rconnect); } void ShowLinks(TreeServer* Current, userrec* user, int hops) { - std::string Parent = TreeRoot->GetName(); + std::string Parent = Utils->TreeRoot->GetName(); if (Current->GetParent()) { Parent = Current->GetParent()->GetName(); } for (unsigned int q = 0; q < Current->ChildCount(); q++) { - if ((HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str()))) + if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str()))) { if (*user->oper) { @@ -3708,24 +3907,24 @@ class ModuleSpanningTree : public Module } } /* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */ - if ((HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!*user->oper)) + if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!*user->oper)) return; - user->WriteServ("364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(FlatLinks && (!*user->oper)) ? ServerInstance->Config->ServerName : Parent.c_str(),(FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str()); + user->WriteServ("364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(Utils->FlatLinks && (!*user->oper)) ? ServerInstance->Config->ServerName : Parent.c_str(),(Utils->FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str()); } int CountLocalServs() { - return TreeRoot->ChildCount(); + return Utils->TreeRoot->ChildCount(); } int CountServs() { - return serverlist.size(); + return Utils->serverlist.size(); } void HandleLinks(const char** parameters, int pcnt, userrec* user) { - ShowLinks(TreeRoot,user,0); + ShowLinks(Utils->TreeRoot,user,0); user->WriteServ("365 %s * :End of /LINKS list.",user->nick); return; } @@ -3794,16 +3993,16 @@ class ModuleSpanningTree : public Module line++; for (unsigned int q = 0; q < Current->ChildCount(); q++) { - if ((HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str()))) + if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str()))) { if (*user->oper) { - ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); + ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); } } else { - ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); + ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); } } } @@ -3818,10 +4017,10 @@ class ModuleSpanningTree : public Module params.push_back(parameters[0]); /* Send it out remotely, generate no reply yet */ - TreeServer* s = FindServerMask(parameters[0]); + TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { - DoOneToOne(user->nick, "MOTD", params, s->GetName()); + Utils->DoOneToOne(user->nick, "MOTD", params, s->GetName()); } else { @@ -3841,10 +4040,10 @@ class ModuleSpanningTree : public Module params.push_back(parameters[0]); /* Send it out remotely, generate no reply yet */ - TreeServer* s = FindServerMask(parameters[0]); + TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { - DoOneToOne(user->nick, "ADMIN", params, s->GetName()); + Utils->DoOneToOne(user->nick, "ADMIN", params, s->GetName()); } else { @@ -3864,11 +4063,11 @@ class ModuleSpanningTree : public Module params.push_back(parameters[0]); params.push_back(parameters[1]); /* Send it out remotely, generate no reply yet */ - TreeServer* s = FindServerMask(parameters[1]); + TreeServer* s = Utils->FindServerMask(parameters[1]); if (s) { params[1] = s->GetName(); - DoOneToOne(user->nick, "STATS", params, s->GetName()); + Utils->DoOneToOne(user->nick, "STATS", params, s->GetName()); } else { @@ -3902,7 +4101,7 @@ class ModuleSpanningTree : public Module } line = 0; // The only recursive bit is called here. - ShowMap(TreeRoot,user,0,matrix,totusers,totservers); + ShowMap(Utils->TreeRoot,user,0,matrix,totusers,totservers); // Process each line one by one. The algorithm has a limit of // 128 servers (which is far more than a spanning tree should have // anyway, so we're ok). This limit can be raised simply by making @@ -3946,10 +4145,10 @@ class ModuleSpanningTree : public Module int HandleSquit(const char** parameters, int pcnt, userrec* user) { - TreeServer* s = FindServerMask(parameters[0]); + TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { - if (s == TreeRoot) + if (s == Utils->TreeRoot) { user->WriteServ("NOTICE %s :*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (%s matches local server name)",user->nick,parameters[0]); return 1; @@ -3980,17 +4179,17 @@ class ModuleSpanningTree : public Module { if ((IS_LOCAL(user)) && (pcnt)) { - TreeServer* found = FindServerMask(parameters[0]); + TreeServer* found = Utils->FindServerMask(parameters[0]); if (found) { // we dont' override for local server - if (found == TreeRoot) + if (found == Utils->TreeRoot) return 0; std::deque params; params.push_back(found->GetName()); params.push_back(user->nick); - DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName()); + Utils->DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName()); } else { @@ -4009,7 +4208,7 @@ class ModuleSpanningTree : public Module { std::deque params; params.push_back(parameters[1]); - DoOneToOne(user->nick,"IDLE",params,remote->server); + Utils->DoOneToOne(user->nick,"IDLE",params,remote->server); return 1; } else if (!remote) @@ -4024,9 +4223,9 @@ class ModuleSpanningTree : public Module void DoPingChecks(time_t curtime) { - for (unsigned int j = 0; j < TreeRoot->ChildCount(); j++) + for (unsigned int j = 0; j < Utils->TreeRoot->ChildCount(); j++) { - TreeServer* serv = TreeRoot->GetChild(j); + TreeServer* serv = Utils->TreeRoot->GetChild(j); TreeSocket* sock = serv->GetSocket(); if (sock) { @@ -4059,7 +4258,7 @@ class ModuleSpanningTree : public Module /* Do we already have an IP? If so, no need to resolve it. */ if (insp_aton(x->IPAddr.c_str(), &binip) > 0) { - TreeSocket* newsocket = new TreeSocket(ServerInstance, x->IPAddr,x->Port,false,10,x->Name.c_str()); + TreeSocket* newsocket = new TreeSocket(Utils, ServerInstance, x->IPAddr,x->Port,false,10,x->Name.c_str()); if (newsocket->GetFd() > -1) { /* Handled automatically on success */ @@ -4068,70 +4267,36 @@ class ModuleSpanningTree : public Module { ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno)); delete newsocket; - this->DoFailOver(x); + Utils->DoFailOver(x); } } else { try { - ServernameResolver* snr = new ServernameResolver(ServerInstance,x->IPAddr, *x); + ServernameResolver* snr = new ServernameResolver(Utils, ServerInstance,x->IPAddr, *x); ServerInstance->AddResolver(snr); } catch (ModuleException& e) { ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason()); - this->DoFailOver(x); + Utils->DoFailOver(x); } } } - void DoFailOver(Link* x) - { - if (x->FailOver.length()) - { - if (x->FailOver == x->Name) - { - ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Some muppet configured the failover for server \002%s\002 to point at itself. Not following it!", x->Name.c_str()); - return; - } - Link* TryThisOne = this->FindLink(x->FailOver.c_str()); - if (TryThisOne) - { - ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Trying failover link for \002%s\002: \002%s\002...", x->Name.c_str(), TryThisOne->Name.c_str()); - ConnectServer(TryThisOne); - } - else - { - ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Invalid failover server specified for server \002%s\002, will not follow!", x->Name.c_str()); - } - } - } - - Link* FindLink(const std::string& name) - { - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) - { - if (ServerInstance->MatchText(x->Name.c_str(), name.c_str())) - { - return &(*x); - } - } - return NULL; - } - void AutoConnectServers(time_t curtime) { - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->AutoConnect) && (curtime >= x->NextConnectTime)) { ServerInstance->Log(DEBUG,"Auto-Connecting %s",x->Name.c_str()); x->NextConnectTime = curtime + x->AutoConnect; - TreeServer* CheckDupe = FindServer(x->Name.c_str()); + TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str()); if (x->FailOver.length()) { - TreeServer* CheckFailOver = FindServer(x->FailOver.c_str()); + TreeServer* CheckFailOver = Utils->FindServer(x->FailOver.c_str()); if (CheckFailOver) { /* The failover for this server is currently a member of the network. @@ -4154,12 +4319,12 @@ class ModuleSpanningTree : public Module int HandleVersion(const char** parameters, int pcnt, userrec* user) { // we've already checked if pcnt > 0, so this is safe - TreeServer* found = FindServerMask(parameters[0]); + TreeServer* found = Utils->FindServerMask(parameters[0]); if (found) { std::string Version = found->GetVersion(); user->WriteServ("351 %s :%s",user->nick,Version.c_str()); - if (found == TreeRoot) + if (found == Utils->TreeRoot) { std::stringstream out(ServerInstance->Config->data005); std::string token = ""; @@ -4190,11 +4355,11 @@ class ModuleSpanningTree : public Module int HandleConnect(const char** parameters, int pcnt, userrec* user) { - for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if (ServerInstance->MatchText(x->Name.c_str(),parameters[0])) { - TreeServer* CheckDupe = FindServer(x->Name.c_str()); + TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str()); if (!CheckDupe) { user->WriteServ("NOTICE %s :*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",user->nick,x->Name.c_str(),(x->HiddenFromStats ? "" : x->IPAddr.c_str()),x->Port); @@ -4216,10 +4381,10 @@ class ModuleSpanningTree : public Module { if (statschar == 'c') { - for (unsigned int i = 0; i < LinkBlocks.size(); i++) + for (unsigned int i = 0; i < Utils->LinkBlocks.size(); i++) { - results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" C *@"+(LinkBlocks[i].HiddenFromStats ? "" : LinkBlocks[i].IPAddr)+" * "+LinkBlocks[i].Name.c_str()+" "+ConvToStr(LinkBlocks[i].Port)+" "+(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-')+(LinkBlocks[i].AutoConnect ? 'a' : '-')+'s'); - results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+LinkBlocks[i].Name.c_str()); + results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" C *@"+(Utils->LinkBlocks[i].HiddenFromStats ? "" : Utils->LinkBlocks[i].IPAddr)+" * "+Utils->LinkBlocks[i].Name.c_str()+" "+ConvToStr(Utils->LinkBlocks[i].Port)+" "+(Utils->LinkBlocks[i].EncryptionKey != "" ? 'e' : '-')+(Utils->LinkBlocks[i].AutoConnect ? 'a' : '-')+'s'); + results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+Utils->LinkBlocks[i].Name.c_str()); } results.push_back(std::string(ServerInstance->Config->ServerName)+" 219 "+user->nick+" "+statschar+" :End of /STATS report"); ServerInstance->SNO->WriteToSnoMask('t',"Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host); @@ -4228,7 +4393,7 @@ class ModuleSpanningTree : public Module return 0; } - virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated) + virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated, const std::string &original_line) { /* If the command doesnt appear to be valid, we dont want to mess with it. */ if (!validated) @@ -4290,7 +4455,7 @@ class ModuleSpanningTree : public Module return 0; } - virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, CmdResult result) + virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, CmdResult result, const std::string &original_line) { if ((result == CMD_SUCCESS) && (ServerInstance->IsValidModuleCommand(command, pcnt, user))) { @@ -4313,13 +4478,13 @@ class ModuleSpanningTree : public Module } } ServerInstance->Log(DEBUG,"Globally route '%s'",command.c_str()); - DoOneToMany(user->nick,command,params); + Utils->DoOneToMany(user->nick,command,params); } } virtual void OnGetServerDescription(const std::string &servername,std::string &description) { - TreeServer* s = FindServer(servername); + TreeServer* s = Utils->FindServer(servername); if (s) { description = s->GetDesc(); @@ -4333,7 +4498,7 @@ class ModuleSpanningTree : public Module std::deque params; params.push_back(dest->nick); params.push_back(channel->name); - DoOneToMany(source->nick,"INVITE",params); + Utils->DoOneToMany(source->nick,"INVITE",params); } } @@ -4342,7 +4507,7 @@ class ModuleSpanningTree : public Module std::deque params; params.push_back(chan->name); params.push_back(":"+topic); - DoOneToMany(user->nick,"TOPIC",params); + Utils->DoOneToMany(user->nick,"TOPIC",params); } virtual void OnWallops(userrec* user, const std::string &text) @@ -4351,7 +4516,7 @@ class ModuleSpanningTree : public Module { std::deque params; params.push_back(":"+text); - DoOneToMany(user->nick,"WALLOPS",params); + Utils->DoOneToMany(user->nick,"WALLOPS",params); } } @@ -4366,7 +4531,7 @@ class ModuleSpanningTree : public Module params.clear(); params.push_back(d->nick); params.push_back(":"+text); - DoOneToOne(user->nick,"NOTICE",params,d->server); + Utils->DoOneToOne(user->nick,"NOTICE",params,d->server); } } else if (target_type == TYPE_CHANNEL) @@ -4380,7 +4545,7 @@ class ModuleSpanningTree : public Module if (status) cname = status + cname; std::deque list; - GetListOfServersForChannel(c,list); + Utils->GetListOfServersForChannel(c,list); unsigned int ucount = list.size(); for (unsigned int i = 0; i < ucount; i++) { @@ -4399,7 +4564,7 @@ class ModuleSpanningTree : public Module std::deque par; par.push_back(target); par.push_back(":"+text); - DoOneToMany(user->nick,"NOTICE",par); + Utils->DoOneToMany(user->nick,"NOTICE",par); } } } @@ -4417,7 +4582,7 @@ class ModuleSpanningTree : public Module params.clear(); params.push_back(d->nick); params.push_back(":"+text); - DoOneToOne(user->nick,"PRIVMSG",params,d->server); + Utils->DoOneToOne(user->nick,"PRIVMSG",params,d->server); } } else if (target_type == TYPE_CHANNEL) @@ -4431,7 +4596,7 @@ class ModuleSpanningTree : public Module if (status) cname = status + cname; std::deque list; - GetListOfServersForChannel(c,list); + Utils->GetListOfServersForChannel(c,list); unsigned int ucount = list.size(); for (unsigned int i = 0; i < ucount; i++) { @@ -4450,7 +4615,7 @@ class ModuleSpanningTree : public Module std::deque par; par.push_back(target); par.push_back(":"+text); - DoOneToMany(user->nick,"PRIVMSG",par); + Utils->DoOneToMany(user->nick,"PRIVMSG",par); } } } @@ -4466,34 +4631,17 @@ class ModuleSpanningTree : public Module // Only do this for local users if (IS_LOCAL(user)) { - char ts[24]; - snprintf(ts,24,"%lu",(unsigned long)channel->age); - std::deque params; params.clear(); params.push_back(channel->name); - - /** XXX: The client protocol will IGNORE this parameter. - * We could make use of it if we wanted to keep the TS - * in step if somehow we lose it. - */ - params.push_back(ts); - - if (channel->GetUserCounter() > 1) - { - // not the first in the channel - DoOneToMany(user->nick,"JOIN",params); - } - else - { - // first in the channel, set up their permissions - // and the channel TS with FJOIN. - params.clear(); - params.push_back(channel->name); - params.push_back(ts); - params.push_back("@,"+std::string(user->nick)); - DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params); - } + // set up their permissions and the channel TS with FJOIN. + // All users are FJOINed now, because a module may specify + // new joining permissions for the user. + params.clear(); + params.push_back(channel->name); + params.push_back(ConvToStr(channel->age)); + params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->nick)); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params); } } @@ -4504,7 +4652,7 @@ class ModuleSpanningTree : public Module return; std::deque params; params.push_back(newhost); - DoOneToMany(user->nick,"FHOST",params); + Utils->DoOneToMany(user->nick,"FHOST",params); } virtual void OnChangeName(userrec* user, const std::string &gecos) @@ -4514,7 +4662,7 @@ class ModuleSpanningTree : public Module return; std::deque params; params.push_back(gecos); - DoOneToMany(user->nick,"FNAME",params); + Utils->DoOneToMany(user->nick,"FNAME",params); } virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage) @@ -4525,7 +4673,7 @@ class ModuleSpanningTree : public Module params.push_back(channel->name); if (partmessage != "") params.push_back(":"+partmessage); - DoOneToMany(user->nick,"PART",params); + Utils->DoOneToMany(user->nick,"PART",params); } } @@ -4544,10 +4692,10 @@ class ModuleSpanningTree : public Module params.push_back("+"+std::string(user->FormatModes())); params.push_back(user->GetIPString()); params.push_back(":"+std::string(user->fullname)); - DoOneToMany(ServerInstance->Config->ServerName,"NICK",params); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"NICK",params); // User is Local, change needs to be reflected! - TreeServer* SourceServer = FindServer(user->server); + TreeServer* SourceServer = Utils->FindServer(user->server); if (SourceServer) { SourceServer->AddUserCount(); @@ -4562,10 +4710,10 @@ class ModuleSpanningTree : public Module { std::deque params; params.push_back(":"+reason); - DoOneToMany(user->nick,"QUIT",params); + Utils->DoOneToMany(user->nick,"QUIT",params); } // Regardless, We need to modify the user Counts.. - TreeServer* SourceServer = FindServer(user->server); + TreeServer* SourceServer = Utils->FindServer(user->server); if (SourceServer) { SourceServer->DelUserCount(); @@ -4579,7 +4727,7 @@ class ModuleSpanningTree : public Module { std::deque params; params.push_back(user->nick); - DoOneToMany(oldnick,"NICK",params); + Utils->DoOneToMany(oldnick,"NICK",params); } } @@ -4591,7 +4739,7 @@ class ModuleSpanningTree : public Module params.push_back(chan->name); params.push_back(user->nick); params.push_back(":"+reason); - DoOneToMany(source->nick,"KICK",params); + Utils->DoOneToMany(source->nick,"KICK",params); } else if (!source) { @@ -4599,7 +4747,7 @@ class ModuleSpanningTree : public Module params.push_back(chan->name); params.push_back(user->nick); params.push_back(":"+reason); - DoOneToMany(ServerInstance->Config->ServerName,"KICK",params); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params); } } @@ -4608,7 +4756,7 @@ class ModuleSpanningTree : public Module std::deque params; params.push_back(dest->nick); params.push_back(":"+reason); - DoOneToMany(source->nick,"KILL",params); + Utils->DoOneToMany(source->nick,"KILL",params); } virtual void OnRehash(const std::string ¶meter) @@ -4617,7 +4765,7 @@ class ModuleSpanningTree : public Module { std::deque params; params.push_back(parameter); - DoOneToMany(ServerInstance->Config->ServerName,"REHASH",params); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"REHASH",params); // check for self if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter)) { @@ -4625,7 +4773,7 @@ class ModuleSpanningTree : public Module ServerInstance->RehashServer(); } } - ReadConfiguration(false); + Utils->ReadConfiguration(false); } // note: the protocol does not allow direct umode +o except @@ -4637,7 +4785,7 @@ class ModuleSpanningTree : public Module { std::deque params; params.push_back(opertype); - DoOneToMany(user->nick,"OPERTYPE",params); + Utils->DoOneToMany(user->nick,"OPERTYPE",params); } } @@ -4656,13 +4804,13 @@ class ModuleSpanningTree : public Module params.push_back(host); params.push_back(sduration); params.push_back(":"+reason); - DoOneToMany(source->nick,stype,params); + Utils->DoOneToMany(source->nick,stype,params); } else { std::deque params; params.push_back(host); - DoOneToMany(source->nick,stype,params); + Utils->DoOneToMany(source->nick,stype,params); } } } @@ -4717,7 +4865,7 @@ class ModuleSpanningTree : public Module std::deque params; params.push_back(u->nick); params.push_back(text); - DoOneToMany(user->nick,"MODE",params); + Utils->DoOneToMany(user->nick,"MODE",params); } else { @@ -4725,7 +4873,7 @@ class ModuleSpanningTree : public Module std::deque params; params.push_back(c->name); params.push_back(text); - DoOneToMany(user->nick,"MODE",params); + Utils->DoOneToMany(user->nick,"MODE",params); } } } @@ -4736,7 +4884,7 @@ class ModuleSpanningTree : public Module { std::deque params; params.push_back(":"+std::string(user->awaymsg)); - DoOneToMany(user->nick,"AWAY",params); + Utils->DoOneToMany(user->nick,"AWAY",params); } } @@ -4746,7 +4894,7 @@ class ModuleSpanningTree : public Module { std::deque params; params.clear(); - DoOneToMany(user->nick,"AWAY",params); + Utils->DoOneToMany(user->nick,"AWAY",params); } } @@ -4792,17 +4940,26 @@ class ModuleSpanningTree : public Module virtual void OnEvent(Event* event) { + std::deque* params = (std::deque*)event->GetData(); + if (event->GetEventID() == "send_metadata") { - std::deque* params = (std::deque*)event->GetData(); if (params->size() < 3) return; (*params)[2] = ":" + (*params)[2]; - DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params); + } + else if (event->GetEventID() == "send_topic") + { + if (params->size() < 2) + return; + (*params)[1] = ":" + (*params)[1]; + params->insert(params->begin() + 1,ServerInstance->Config->ServerName); + params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time())); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params); } else if (event->GetEventID() == "send_mode") { - std::deque* params = (std::deque*)event->GetData(); if (params->size() < 2) return; // Insert the TS value of the object, either userrec or chanrec @@ -4821,17 +4978,20 @@ class ModuleSpanningTree : public Module } } params->insert(params->begin() + 1,ConvToStr(ourTS)); - DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params); } } virtual ~ModuleSpanningTree() { + ServerInstance->Log(DEBUG,"Performing unload of spanningtree!"); + /* This will also free the listeners */ + delete Utils; } virtual Version GetVersion() { - return Version(1,0,0,0,VF_STATIC|VF_VENDOR); + return Version(1,1,0,2,VF_VENDOR,API_VERSION); } void Implements(char* List) @@ -4858,16 +5018,41 @@ class ModuleSpanningTree : public Module } }; -void DoFailOver(Link* x) +void SpanningTreeUtilities::DoFailOver(Link* x) { - TreeProtocolModule->DoFailOver(x); + if (x->FailOver.length()) + { + if (x->FailOver == x->Name) + { + ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Some muppet configured the failover for server \002%s\002 to point at itself. Not following it!", x->Name.c_str()); + return; + } + Link* TryThisOne = this->FindLink(x->FailOver.c_str()); + if (TryThisOne) + { + ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Trying failover link for \002%s\002: \002%s\002...", x->Name.c_str(), TryThisOne->Name.c_str()); + Creator->ConnectServer(TryThisOne); + } + else + { + ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Invalid failover server specified for server \002%s\002, will not follow!", x->Name.c_str()); + } + } } -Link* FindLink(const std::string& name) +Link* SpanningTreeUtilities::FindLink(const std::string& name) { - return TreeProtocolModule->FindLink(name); + for (std::vector::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++) + { + if (ServerInstance->MatchText(x->Name.c_str(), name.c_str())) + { + return &(*x); + } + } + return NULL; } + class ModuleSpanningTreeFactory : public ModuleFactory { public: @@ -4881,8 +5066,7 @@ class ModuleSpanningTreeFactory : public ModuleFactory virtual Module * CreateModule(InspIRCd* Me) { - TreeProtocolModule = new ModuleSpanningTree(Me); - return TreeProtocolModule; + return new ModuleSpanningTree(Me); } };