From f2acdbc3820f0f4f5ef76a0a64e73d2a320df91f Mon Sep 17 00:00:00 2001 From: peavey Date: Mon, 16 Jul 2007 17:30:04 +0000 Subject: OOPS! We try again, since I'm smoking craq. LF is 0x0a NOT CR. git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@7456 e03df62e-2008-0410-955e-edbf42e46eb7 --- src/modules/m_spanningtree/README | 25 +- src/modules/m_spanningtree/handshaketimer.cpp | 63 +- src/modules/m_spanningtree/handshaketimer.h | 38 +- src/modules/m_spanningtree/link.h | 43 +- src/modules/m_spanningtree/main.cpp | 1393 +++++++++++++++++++++- src/modules/m_spanningtree/main.h | 199 +++- src/modules/m_spanningtree/rconnect.cpp | 68 +- src/modules/m_spanningtree/rconnect.h | 29 +- src/modules/m_spanningtree/resolvers.cpp | 89 +- src/modules/m_spanningtree/resolvers.h | 91 +- src/modules/m_spanningtree/rsquit.cpp | 124 +- src/modules/m_spanningtree/rsquit.h | 30 +- src/modules/m_spanningtree/timesynctimer.cpp | 53 +- src/modules/m_spanningtree/timesynctimer.h | 48 +- src/modules/m_spanningtree/treeserver.cpp | 326 +++++- src/modules/m_spanningtree/treeserver.h | 187 ++- src/modules/m_spanningtree/treesocket.h | 414 ++++++- src/modules/m_spanningtree/treesocket1.cpp | 1274 +++++++++++++++++++- src/modules/m_spanningtree/treesocket2.cpp | 1555 ++++++++++++++++++++++++- src/modules/m_spanningtree/utils.cpp | 650 ++++++++++- src/modules/m_spanningtree/utils.h | 195 +++- 21 files changed, 6873 insertions(+), 21 deletions(-) (limited to 'src/modules/m_spanningtree') diff --git a/src/modules/m_spanningtree/README b/src/modules/m_spanningtree/README index 76c678c1f..ff23e0381 100644 --- a/src/modules/m_spanningtree/README +++ b/src/modules/m_spanningtree/README @@ -1 +1,24 @@ -m_spanningtree -------------- This directory contains all files required to build the m_spanningtree.so module. Directories like this one starting with m_ and containing .cpp files are aggregated together by the makefile to form a single .so, with the same name as the directory. This directory contains the following files: * handshaketimer.cpp Code for detecting end of ziplink/ssl handshake * handshaketimer.h Header for above code * link.h Contains the definition of the Link block class * main.cpp The main group of classes and code for the module class * main.h The header for the main file * resolvers.h The header file that defines certain DNS utility classes * treesocket.cpp Contains code that inherits InspSocket into a server socket * treesocket.h Header definitions for above code * treeserver.cpp Contains code that defines the behaviour of a single server * treeserver.h Header definitions for above code * utils.cpp Contains general and message routing utility classes * utils.h Header code for general and message routing utilities Have fun -- Brain :-) \ No newline at end of file +m_spanningtree +-------------- + +This directory contains all files required to build the m_spanningtree.so module. +Directories like this one starting with m_ and containing .cpp files are aggregated +together by the makefile to form a single .so, with the same name as the directory. + +This directory contains the following files: + +* handshaketimer.cpp Code for detecting end of ziplink/ssl handshake +* handshaketimer.h Header for above code +* link.h Contains the definition of the Link block class +* main.cpp The main group of classes and code for the module class +* main.h The header for the main file +* resolvers.h The header file that defines certain DNS utility classes +* treesocket.cpp Contains code that inherits InspSocket into a server socket +* treesocket.h Header definitions for above code +* treeserver.cpp Contains code that defines the behaviour of a single server +* treeserver.h Header definitions for above code +* utils.cpp Contains general and message routing utility classes +* utils.h Header code for general and message routing utilities + +Have fun + -- Brain :-) diff --git a/src/modules/m_spanningtree/handshaketimer.cpp b/src/modules/m_spanningtree/handshaketimer.cpp index 93856f467..4aeb1da88 100644 --- a/src/modules/m_spanningtree/handshaketimer.cpp +++ b/src/modules/m_spanningtree/handshaketimer.cpp @@ -1 +1,62 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" #include "m_spanningtree/handshaketimer.h" /* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ HandshakeTimer::HandshakeTimer(InspIRCd* Inst, TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay) : InspTimer(delay, time(NULL)), Instance(Inst), sock(s), lnk(l), Utils(u) { thefd = sock->GetFd(); } void HandshakeTimer::Tick(time_t TIME) { if (Instance->SE->GetRef(thefd) == sock) { if (!sock->GetHook()) { sock->SendCapabilities(); } else { if (sock->GetHook() && InspSocketHSCompleteRequest(sock, (Module*)Utils->Creator, sock->GetHook()).Send()) { InspSocketAttachCertRequest(sock, (Module*)Utils->Creator, sock->GetHook()).Send(); sock->SendCapabilities(); } else { Instance->Timers->AddTimer(new HandshakeTimer(Instance, sock, lnk, Utils, 1)); } } } } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" +#include "m_spanningtree/handshaketimer.h" + +/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ + +HandshakeTimer::HandshakeTimer(InspIRCd* Inst, TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay) : InspTimer(delay, time(NULL)), Instance(Inst), sock(s), lnk(l), Utils(u) +{ + thefd = sock->GetFd(); +} + +void HandshakeTimer::Tick(time_t TIME) +{ + if (Instance->SE->GetRef(thefd) == sock) + { + if (!sock->GetHook()) + { + sock->SendCapabilities(); + } + else + { + if (sock->GetHook() && InspSocketHSCompleteRequest(sock, (Module*)Utils->Creator, sock->GetHook()).Send()) + { + InspSocketAttachCertRequest(sock, (Module*)Utils->Creator, sock->GetHook()).Send(); + sock->SendCapabilities(); + } + else + { + Instance->Timers->AddTimer(new HandshakeTimer(Instance, sock, lnk, Utils, 1)); + } + } + } +} + diff --git a/src/modules/m_spanningtree/handshaketimer.h b/src/modules/m_spanningtree/handshaketimer.h index e94fe67d7..496102dda 100644 --- a/src/modules/m_spanningtree/handshaketimer.h +++ b/src/modules/m_spanningtree/handshaketimer.h @@ -1 +1,37 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __HANDSHAKE_TIMER_H__ #define __HANDSHAKE_TIMER_H__ #include "inspircd.h" #include "timer.h" class SpanningTreeUtilities; class TreeSocket; class Link; class HandshakeTimer : public InspTimer { private: InspIRCd* Instance; TreeSocket* sock; Link* lnk; SpanningTreeUtilities* Utils; int thefd; public: HandshakeTimer(InspIRCd* Inst, TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay); virtual void Tick(time_t TIME); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __HANDSHAKE_TIMER_H__ +#define __HANDSHAKE_TIMER_H__ + +#include "inspircd.h" +#include "timer.h" + +class SpanningTreeUtilities; +class TreeSocket; +class Link; + +class HandshakeTimer : public InspTimer +{ + private: + InspIRCd* Instance; + TreeSocket* sock; + Link* lnk; + SpanningTreeUtilities* Utils; + int thefd; + public: + HandshakeTimer(InspIRCd* Inst, TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay); + virtual void Tick(time_t TIME); +}; + +#endif diff --git a/src/modules/m_spanningtree/link.h b/src/modules/m_spanningtree/link.h index 9636d565f..3de326153 100644 --- a/src/modules/m_spanningtree/link.h +++ b/src/modules/m_spanningtree/link.h @@ -1 +1,42 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __LINK_H__ #define __LINK_H__ /** 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; std::string AllowMask; unsigned long AutoConnect; time_t NextConnectTime; bool HiddenFromStats; std::string FailOver; std::string Hook; int Timeout; std::string Bind; bool Hidden; }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __LINK_H__ +#define __LINK_H__ + +/** 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; + std::string AllowMask; + unsigned long AutoConnect; + time_t NextConnectTime; + bool HiddenFromStats; + std::string FailOver; + std::string Hook; + int Timeout; + std::string Bind; + bool Hidden; +}; + +#endif diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp index 352cae870..1cc18dae6 100644 --- a/src/modules/m_spanningtree/main.cpp +++ b/src/modules/m_spanningtree/main.cpp @@ -1 +1,1392 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ /* $ModDesc: Provides a spanning tree server link protocol */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/timesynctimer.h" #include "m_spanningtree/resolvers.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" #include "m_spanningtree/rconnect.h" #include "m_spanningtree/rsquit.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */ ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me) : Module(Me), max_local(0), max_global(0) { ServerInstance->UseInterface("InspSocketHook"); Utils = new SpanningTreeUtilities(Me, this); command_rconnect = new cmd_rconnect(ServerInstance, this, Utils); ServerInstance->AddCommand(command_rconnect); command_rsquit = new cmd_rsquit(ServerInstance, this, Utils); ServerInstance->AddCommand(command_rsquit); if (Utils->EnableTimeSync) { SyncTimer = new TimeSyncTimer(ServerInstance, this); ServerInstance->Timers->AddTimer(SyncTimer); } else SyncTimer = NULL; RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils); ServerInstance->Timers->AddTimer(RefreshTimer); } void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops) { std::string Parent = Utils->TreeRoot->GetName(); if (Current->GetParent()) { Parent = Current->GetParent()->GetName(); } for (unsigned int q = 0; q < Current->ChildCount(); q++) { if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))) { if (*user->oper) { ShowLinks(Current->GetChild(q),user,hops+1); } } else { ShowLinks(Current->GetChild(q),user,hops+1); } } /* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */ if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!IS_OPER(user))) return; /* Or if the server is hidden and they're not an oper */ else if ((Current->Hidden) && (!IS_OPER(user))) return; user->WriteServ("364 %s %s %s :%d %s", user->nick,Current->GetName().c_str(), (Utils->FlatLinks && (!IS_OPER(user))) ? ServerInstance->Config->ServerName : Parent.c_str(), (Utils->FlatLinks && (!IS_OPER(user))) ? 0 : hops, Current->GetDesc().c_str()); } int ModuleSpanningTree::CountLocalServs() { return Utils->TreeRoot->ChildCount(); } int ModuleSpanningTree::CountServs() { return Utils->serverlist.size(); } void ModuleSpanningTree::HandleLinks(const char** parameters, int pcnt, userrec* user) { ShowLinks(Utils->TreeRoot,user,0); user->WriteServ("365 %s * :End of /LINKS list.",user->nick); return; } void ModuleSpanningTree::HandleLusers(const char** parameters, int pcnt, userrec* user) { unsigned int n_users = ServerInstance->UserCount(); /* Only update these when someone wants to see them, more efficient */ if ((unsigned int)ServerInstance->LocalUserCount() > max_local) max_local = ServerInstance->LocalUserCount(); if (n_users > max_global) max_global = n_users; unsigned int ulined_count = 0; unsigned int ulined_local_count = 0; /* If ulined are hidden and we're not an oper, count the number of ulined servers hidden, * locally and globally (locally means directly connected to us) */ if ((Utils->HideULines) && (!*user->oper)) { for (server_hash::iterator q = Utils->serverlist.begin(); q != Utils->serverlist.end(); q++) { if (ServerInstance->ULine(q->second->GetName().c_str())) { ulined_count++; if (q->second->GetParent() == Utils->TreeRoot) ulined_local_count++; } } } user->WriteServ("251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-ServerInstance->InvisibleUserCount(),ServerInstance->InvisibleUserCount(),ulined_count ? this->CountServs() - ulined_count : this->CountServs()); if (ServerInstance->OperCount()) user->WriteServ("252 %s %d :operator(s) online",user->nick,ServerInstance->OperCount()); if (ServerInstance->UnregisteredUserCount()) user->WriteServ("253 %s %d :unknown connections",user->nick,ServerInstance->UnregisteredUserCount()); if (ServerInstance->ChannelCount()) user->WriteServ("254 %s %d :channels formed",user->nick,ServerInstance->ChannelCount()); user->WriteServ("255 %s :I have %d clients and %d servers",user->nick,ServerInstance->LocalUserCount(),ulined_local_count ? this->CountLocalServs() - ulined_local_count : this->CountLocalServs()); user->WriteServ("265 %s :Current Local Users: %d Max: %d",user->nick,ServerInstance->LocalUserCount(),max_local); user->WriteServ("266 %s :Current Global Users: %d Max: %d",user->nick,n_users,max_global); return; } std::string ModuleSpanningTree::TimeToStr(time_t secs) { time_t mins_up = secs / 60; time_t hours_up = mins_up / 60; time_t days_up = hours_up / 24; secs = secs % 60; mins_up = mins_up % 60; hours_up = hours_up % 24; return ((days_up ? (ConvToStr(days_up) + "d") : std::string("")) + (hours_up ? (ConvToStr(hours_up) + "h") : std::string("")) + (mins_up ? (ConvToStr(mins_up) + "m") : std::string("")) + ConvToStr(secs) + "s"); } const std::string ModuleSpanningTree::MapOperInfo(TreeServer* Current) { time_t secs_up = ServerInstance->Time() - Current->age; return (" [Up: " + TimeToStr(secs_up) + " Lag: "+ConvToStr(Current->rtt)+"s]"); } // WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS. void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][128], float &totusers, float &totservers) { if (line < 128) { for (int t = 0; t < depth; t++) { matrix[line][t] = ' '; } // For Aligning, we need to work out exactly how deep this thing is, and produce // a 'Spacer' String to compensate. char spacer[40]; memset(spacer,' ',40); if ((40 - Current->GetName().length() - depth) > 1) { spacer[40 - Current->GetName().length() - depth] = '\0'; } else { spacer[5] = '\0'; } float percent; char text[128]; /* Neat and tidy default values, as we're dealing with a matrix not a simple string */ memset(text, 0, 128); if (ServerInstance->clientlist->size() == 0) { // If there are no users, WHO THE HELL DID THE /MAP?!?!?! percent = 0; } else { percent = ((float)Current->GetUserCount() / (float)ServerInstance->clientlist->size()) * 100; } const std::string operdata = IS_OPER(user) ? MapOperInfo(Current) : ""; snprintf(text, 126, "%s %s%5d [%5.2f%%]%s", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent, operdata.c_str()); totusers += Current->GetUserCount(); totservers++; strlcpy(&matrix[line][depth],text,126); line++; for (unsigned int q = 0; q < Current->ChildCount(); q++) { if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))) { if (*user->oper) { ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); } } else { ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); } } } } int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* user) { if (pcnt > 0) { if (match(ServerInstance->Config->ServerName, parameters[0])) return 0; /* Remote MOTD, the server is within the 1st parameter */ std::deque params; params.push_back(parameters[0]); /* Send it out remotely, generate no reply yet */ TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { params[0] = s->GetName(); Utils->DoOneToOne(user->nick, "MOTD", params, s->GetName()); } else user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]); return 1; } return 0; } int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec* user) { if (pcnt > 0) { if (match(ServerInstance->Config->ServerName, parameters[0])) return 0; /* Remote ADMIN, the server is within the 1st parameter */ std::deque params; params.push_back(parameters[0]); /* Send it out remotely, generate no reply yet */ TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { params[0] = s->GetName(); Utils->DoOneToOne(user->nick, "ADMIN", params, s->GetName()); } else user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]); return 1; } return 0; } int ModuleSpanningTree::HandleModules(const char** parameters, int pcnt, userrec* user) { if (pcnt > 0) { if (match(ServerInstance->Config->ServerName, parameters[0])) return 0; std::deque params; params.push_back(parameters[0]); TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { params[0] = s->GetName(); Utils->DoOneToOne(user->nick, "MODULES", params, s->GetName()); } else user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]); return 1; } return 0; } int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, userrec* user) { if (pcnt > 1) { if (match(ServerInstance->Config->ServerName, parameters[1])) return 0; /* Remote STATS, the server is within the 2nd parameter */ std::deque params; params.push_back(parameters[0]); params.push_back(parameters[1]); /* Send it out remotely, generate no reply yet */ TreeServer* s = Utils->FindServerMask(parameters[1]); if (s) { params[1] = s->GetName(); Utils->DoOneToOne(user->nick, "STATS", params, s->GetName()); } else { user->WriteServ( "402 %s %s :No such server", user->nick, parameters[1]); } return 1; } return 0; } // Ok, prepare to be confused. // After much mulling over how to approach this, it struck me that // the 'usual' way of doing a /MAP isnt the best way. Instead of // keeping track of a ton of ascii characters, and line by line // under recursion working out where to place them using multiplications // and divisons, we instead render the map onto a backplane of characters // (a character matrix), then draw the branches as a series of "L" shapes // from the nodes. This is not only friendlier on CPU it uses less stack. void ModuleSpanningTree::HandleMap(const char** parameters, int pcnt, userrec* user) { // This array represents a virtual screen which we will // "scratch" draw to, as the console device of an irc // client does not provide for a proper terminal. float totusers = 0; float totservers = 0; char matrix[128][128]; for (unsigned int t = 0; t < 128; t++) { matrix[t][0] = '\0'; } line = 0; // The only recursive bit is called here. 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 // the character matrix deeper, 128 rows taking 10k of memory. for (int l = 1; l < line; l++) { // scan across the line looking for the start of the // servername (the recursive part of the algorithm has placed // the servers at indented positions depending on what they // are related to) int first_nonspace = 0; while (matrix[l][first_nonspace] == ' ') { first_nonspace++; } first_nonspace--; // Draw the `- (corner) section: this may be overwritten by // another L shape passing along the same vertical pane, becoming // a |- (branch) section instead. matrix[l][first_nonspace] = '-'; matrix[l][first_nonspace-1] = '`'; int l2 = l - 1; // Draw upwards until we hit the parent server, causing possibly // other corners (`-) to become branches (|-) while ((matrix[l2][first_nonspace-1] == ' ') || (matrix[l2][first_nonspace-1] == '`')) { matrix[l2][first_nonspace-1] = '|'; l2--; } } // dump the whole lot to the user. This is the easy bit, honest. for (int t = 0; t < line; t++) { user->WriteServ("006 %s :%s",user->nick,&matrix[t][0]); } float avg_users = totusers / totservers; user->WriteServ("270 %s :%.0f server%s and %.0f user%s, average %.2f users per server",user->nick,totservers,(totservers > 1 ? "s" : ""),totusers,(totusers > 1 ? "s" : ""),avg_users); user->WriteServ("007 %s :End of /MAP",user->nick); return; } int ModuleSpanningTree::HandleSquit(const char** parameters, int pcnt, userrec* user) { TreeServer* s = Utils->FindServerMask(parameters[0]); if (s) { 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; } TreeSocket* sock = s->GetSocket(); if (sock) { ServerInstance->SNO->WriteToSnoMask('l',"SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick); sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost()); ServerInstance->SE->DelFd(sock); sock->Close(); } else { if (IS_LOCAL(user)) user->WriteServ("NOTICE %s :*** WARNING: Using SQUIT to split remote servers is deprecated. Please use RSQUIT instead.",user->nick); } } else { user->WriteServ("NOTICE %s :*** SQUIT: The server \002%s\002 does not exist on the network.",user->nick,parameters[0]); } return 1; } int ModuleSpanningTree::HandleTime(const char** parameters, int pcnt, userrec* user) { if ((IS_LOCAL(user)) && (pcnt)) { TreeServer* found = Utils->FindServerMask(parameters[0]); if (found) { // we dont' override for local server if (found == Utils->TreeRoot) return 0; std::deque params; params.push_back(found->GetName()); params.push_back(user->nick); Utils->DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName()); } else { user->WriteServ("402 %s %s :No such server",user->nick,parameters[0]); } } return 1; } int ModuleSpanningTree::HandleRemoteWhois(const char** parameters, int pcnt, userrec* user) { if ((IS_LOCAL(user)) && (pcnt > 1)) { userrec* remote = ServerInstance->FindNick(parameters[1]); if ((remote) && (remote->GetFd() < 0)) { std::deque params; params.push_back(parameters[1]); Utils->DoOneToOne(user->nick,"IDLE",params,remote->server); return 1; } else if (!remote) { user->WriteServ("401 %s %s :No such nick/channel",user->nick, parameters[1]); user->WriteServ("318 %s %s :End of /WHOIS list.",user->nick, parameters[1]); return 1; } } return 0; } void ModuleSpanningTree::DoPingChecks(time_t curtime) { for (unsigned int j = 0; j < Utils->TreeRoot->ChildCount(); j++) { TreeServer* serv = Utils->TreeRoot->GetChild(j); TreeSocket* sock = serv->GetSocket(); if (sock) { if (curtime >= serv->NextPingTime()) { if (serv->AnsweredLastPing()) { sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName()); serv->SetNextPingTime(curtime + 60); serv->LastPing = curtime; serv->Warned = false; } else { /* they didnt answer, boot them */ sock->SendError("Ping timeout"); sock->Squit(serv,"Ping timeout"); /*** XXX SOCKET CULL ***/ return; } } else if ((Utils->PingWarnTime) && (!serv->Warned) && (curtime >= serv->NextPingTime() - (60 - Utils->PingWarnTime)) && (!serv->AnsweredLastPing())) { /* The server hasnt responded, send a warning to opers */ ServerInstance->SNO->WriteToSnoMask('l',"Server \002%s\002 has not responded to PING for %d seconds, high latency.", serv->GetName().c_str(), Utils->PingWarnTime); serv->Warned = true; } } } /* Cancel remote burst mode on any servers which still have it enabled due to latency/lack of data. * This prevents lost REMOTECONNECT notices */ for (server_hash::iterator i = Utils->serverlist.begin(); i != Utils->serverlist.end(); i++) Utils->SetRemoteBursting(i->second, false); } void ModuleSpanningTree::ConnectServer(Link* x) { bool ipvalid = true; QueryType start_type = DNS_QUERY_A; #ifdef IPV6 start_type = DNS_QUERY_AAAA; if (strchr(x->IPAddr.c_str(),':')) { in6_addr n; if (inet_pton(AF_INET6, x->IPAddr.c_str(), &n) < 1) ipvalid = false; } else #endif { in_addr n; if (inet_aton(x->IPAddr.c_str(),&n) < 1) ipvalid = false; } /* Do we already have an IP? If so, no need to resolve it. */ if (ipvalid) { /* Gave a hook, but it wasnt one we know */ if ((!x->Hook.empty()) && (Utils->hooks.find(x->Hook.c_str()) == Utils->hooks.end())) return; TreeSocket* newsocket = new TreeSocket(Utils, ServerInstance, x->IPAddr,x->Port,false,x->Timeout ? x->Timeout : 10,x->Name.c_str(), x->Bind, x->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]); if (newsocket->GetFd() > -1) { /* Handled automatically on success */ } else { ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno)); delete newsocket; Utils->DoFailOver(x); } } else { try { bool cached; ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached, start_type); ServerInstance->AddResolver(snr, cached); } catch (ModuleException& e) { ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason()); Utils->DoFailOver(x); } } } void ModuleSpanningTree::AutoConnectServers(time_t curtime) { for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->AutoConnect) && (curtime >= x->NextConnectTime)) { x->NextConnectTime = curtime + x->AutoConnect; TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str()); if (x->FailOver.length()) { TreeServer* CheckFailOver = Utils->FindServer(x->FailOver.c_str()); if (CheckFailOver) { /* The failover for this server is currently a member of the network. * The failover probably succeeded, where the main link did not. * Don't try the main link until the failover is gone again. */ continue; } } if (!CheckDupe) { // an autoconnected server is not connected. Check if its time to connect it ServerInstance->SNO->WriteToSnoMask('l',"AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect); this->ConnectServer(&(*x)); } } } } int ModuleSpanningTree::HandleVersion(const char** parameters, int pcnt, userrec* user) { // we've already checked if pcnt > 0, so this is safe 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 == Utils->TreeRoot) { ServerInstance->Config->Send005(user); } } else { user->WriteServ("402 %s %s :No such server",user->nick,parameters[0]); } return 1; } int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec* user) { for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if (ServerInstance->MatchText(x->Name.c_str(),parameters[0])) { 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); ConnectServer(&(*x)); return 1; } else { user->WriteServ("NOTICE %s :*** CONNECT: Server \002%s\002 already exists on the network and is connected via \002%s\002",user->nick,x->Name.c_str(),CheckDupe->GetParent()->GetName().c_str()); return 1; } } } user->WriteServ("NOTICE %s :*** CONNECT: No server matching \002%s\002 could be found in the config file.",user->nick,parameters[0]); return 1; } void ModuleSpanningTree::BroadcastTimeSync() { if (Utils->MasterTime) { std::deque params; params.push_back(ConvToStr(ServerInstance->Time(false))); params.push_back("FORCE"); Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params); } } int ModuleSpanningTree::OnStats(char statschar, userrec* user, string_list &results) { if ((statschar == 'c') || (statschar == 'n')) { for (unsigned int i = 0; i < Utils->LinkBlocks.size(); i++) { results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" "+statschar+" *@"+(Utils->LinkBlocks[i].HiddenFromStats ? "" : Utils->LinkBlocks[i].IPAddr)+" * "+Utils->LinkBlocks[i].Name.c_str()+" "+ConvToStr(Utils->LinkBlocks[i].Port)+" "+(Utils->LinkBlocks[i].Hook.empty() ? "plaintext" : Utils->LinkBlocks[i].Hook)+" "+(Utils->LinkBlocks[i].AutoConnect ? 'a' : '-')+'s'); if (statschar == 'c') 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',"%s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host); return 1; } if (statschar == 'p') { /* show all server ports, after showing client ports. -- w00t */ for (unsigned int i = 0; i < Utils->Bindings.size(); i++) { std::string ip = Utils->Bindings[i]->IP; if (ip.empty()) ip = "*"; std::string transport("plaintext"); if (Utils->Bindings[i]->GetHook()) transport = InspSocketNameRequest(this, Utils->Bindings[i]->GetHook()).Send(); results.push_back(ConvToStr(ServerInstance->Config->ServerName) + " 249 "+user->nick+" :" + ip + ":" + ConvToStr(Utils->Bindings[i]->port)+ " (server, " + transport + ")"); } } return 0; } int ModuleSpanningTree::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) return 0; if (command == "CONNECT") { return this->HandleConnect(parameters,pcnt,user); } else if (command == "STATS") { return this->HandleStats(parameters,pcnt,user); } else if (command == "MOTD") { return this->HandleMotd(parameters,pcnt,user); } else if (command == "ADMIN") { return this->HandleAdmin(parameters,pcnt,user); } else if (command == "SQUIT") { return this->HandleSquit(parameters,pcnt,user); } else if (command == "MAP") { this->HandleMap(parameters,pcnt,user); return 1; } else if ((command == "TIME") && (pcnt > 0)) { return this->HandleTime(parameters,pcnt,user); } else if (command == "LUSERS") { this->HandleLusers(parameters,pcnt,user); return 1; } else if (command == "LINKS") { this->HandleLinks(parameters,pcnt,user); return 1; } else if (command == "WHOIS") { if (pcnt > 1) { // remote whois return this->HandleRemoteWhois(parameters,pcnt,user); } } else if ((command == "VERSION") && (pcnt > 0)) { this->HandleVersion(parameters,pcnt,user); return 1; } else if ((command == "MODULES") && (pcnt > 0)) { return this->HandleModules(parameters,pcnt,user); } return 0; } void ModuleSpanningTree::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))) { // this bit of code cleverly routes all module commands // to all remote severs *automatically* so that modules // can just handle commands locally, without having // to have any special provision in place for remote // commands and linking protocols. std::deque params; params.clear(); for (int j = 0; j < pcnt; j++) { if (strchr(parameters[j],' ')) { params.push_back(":" + std::string(parameters[j])); } else { params.push_back(std::string(parameters[j])); } } Utils->DoOneToMany(user->nick,command,params); } } void ModuleSpanningTree::OnGetServerDescription(const std::string &servername,std::string &description) { TreeServer* s = Utils->FindServer(servername); if (s) { description = s->GetDesc(); } } void ModuleSpanningTree::OnUserInvite(userrec* source,userrec* dest,chanrec* channel) { if (IS_LOCAL(source)) { std::deque params; params.push_back(dest->nick); params.push_back(channel->name); Utils->DoOneToMany(source->nick,"INVITE",params); } } void ModuleSpanningTree::OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic) { std::deque params; params.push_back(chan->name); params.push_back(":"+topic); Utils->DoOneToMany(user->nick,"TOPIC",params); } void ModuleSpanningTree::OnWallops(userrec* user, const std::string &text) { if (IS_LOCAL(user)) { std::deque params; params.push_back(":"+text); Utils->DoOneToMany(user->nick,"WALLOPS",params); } } void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list) { if (target_type == TYPE_USER) { userrec* d = (userrec*)dest; if ((d->GetFd() < 0) && (IS_LOCAL(user))) { std::deque params; params.clear(); params.push_back(d->nick); params.push_back(":"+text); Utils->DoOneToOne(user->nick,"NOTICE",params,d->server); } } else if (target_type == TYPE_CHANNEL) { if (IS_LOCAL(user)) { chanrec *c = (chanrec*)dest; if (c) { std::string cname = c->name; if (status) cname = status + cname; TreeServerList list; Utils->GetListOfServersForChannel(c,list,status,exempt_list); for (TreeServerList::iterator i = list.begin(); i != list.end(); i++) { TreeSocket* Sock = i->second->GetSocket(); if (Sock) Sock->WriteLine(":"+std::string(user->nick)+" NOTICE "+cname+" :"+text); } } } } else if (target_type == TYPE_SERVER) { if (IS_LOCAL(user)) { char* target = (char*)dest; std::deque par; par.push_back(target); par.push_back(":"+text); Utils->DoOneToMany(user->nick,"NOTICE",par); } } } void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list) { if (target_type == TYPE_USER) { // route private messages which are targetted at clients only to the server // which needs to receive them userrec* d = (userrec*)dest; if ((d->GetFd() < 0) && (IS_LOCAL(user))) { std::deque params; params.clear(); params.push_back(d->nick); params.push_back(":"+text); Utils->DoOneToOne(user->nick,"PRIVMSG",params,d->server); } } else if (target_type == TYPE_CHANNEL) { if (IS_LOCAL(user)) { chanrec *c = (chanrec*)dest; if (c) { std::string cname = c->name; if (status) cname = status + cname; TreeServerList list; Utils->GetListOfServersForChannel(c,list,status,exempt_list); for (TreeServerList::iterator i = list.begin(); i != list.end(); i++) { TreeSocket* Sock = i->second->GetSocket(); if (Sock) Sock->WriteLine(":"+std::string(user->nick)+" PRIVMSG "+cname+" :"+text); } } } } else if (target_type == TYPE_SERVER) { if (IS_LOCAL(user)) { char* target = (char*)dest; std::deque par; par.push_back(target); par.push_back(":"+text); Utils->DoOneToMany(user->nick,"PRIVMSG",par); } } } void ModuleSpanningTree::OnBackgroundTimer(time_t curtime) { AutoConnectServers(curtime); DoPingChecks(curtime); } void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel, bool &silent) { // Only do this for local users if (IS_LOCAL(user)) { if (channel->GetUserCounter() == 1) { std::deque 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.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); /* First user in, sync the modes for the channel */ params.pop_back(); params.push_back(channel->ChanModes(true)); Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params); } else { std::deque params; params.push_back(channel->name); params.push_back(ConvToStr(channel->age)); Utils->DoOneToMany(user->nick,"JOIN",params); } } } void ModuleSpanningTree::OnChangeHost(userrec* user, const std::string &newhost) { // only occurs for local clients if (user->registered != REG_ALL) return; std::deque params; params.push_back(newhost); Utils->DoOneToMany(user->nick,"FHOST",params); } void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos) { // only occurs for local clients if (user->registered != REG_ALL) return; std::deque params; params.push_back(gecos); Utils->DoOneToMany(user->nick,"FNAME",params); } void ModuleSpanningTree::OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage, bool &silent) { if (IS_LOCAL(user)) { std::deque params; params.push_back(channel->name); if (!partmessage.empty()) params.push_back(":"+partmessage); Utils->DoOneToMany(user->nick,"PART",params); } } void ModuleSpanningTree::OnUserConnect(userrec* user) { char agestr[MAXBUF]; if (IS_LOCAL(user)) { std::deque params; snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age); params.push_back(agestr); params.push_back(user->nick); params.push_back(user->host); params.push_back(user->dhost); params.push_back(user->ident); params.push_back("+"+std::string(user->FormatModes())); params.push_back(user->GetIPString()); params.push_back(":"+std::string(user->fullname)); Utils->DoOneToMany(ServerInstance->Config->ServerName,"NICK",params); // User is Local, change needs to be reflected! TreeServer* SourceServer = Utils->FindServer(user->server); if (SourceServer) { SourceServer->AddUserCount(); } } } void ModuleSpanningTree::OnUserQuit(userrec* user, const std::string &reason, const std::string &oper_message) { if ((IS_LOCAL(user)) && (user->registered == REG_ALL)) { std::deque params; if (oper_message != reason) { params.push_back(":"+oper_message); Utils->DoOneToMany(user->nick,"OPERQUIT",params); } params.clear(); params.push_back(":"+reason); Utils->DoOneToMany(user->nick,"QUIT",params); } // Regardless, We need to modify the user Counts.. TreeServer* SourceServer = Utils->FindServer(user->server); if (SourceServer) { SourceServer->DelUserCount(); } } void ModuleSpanningTree::OnUserPostNick(userrec* user, const std::string &oldnick) { if (IS_LOCAL(user)) { std::deque params; params.push_back(user->nick); Utils->DoOneToMany(oldnick,"NICK",params); } } void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason, bool &silent) { if ((source) && (IS_LOCAL(source))) { std::deque params; params.push_back(chan->name); params.push_back(user->nick); params.push_back(":"+reason); Utils->DoOneToMany(source->nick,"KICK",params); } else if (!source) { std::deque params; params.push_back(chan->name); params.push_back(user->nick); params.push_back(":"+reason); Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params); } } void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason, const std::string &operreason) { std::deque params; params.push_back(":"+reason); Utils->DoOneToMany(dest->nick,"OPERQUIT",params); params.clear(); params.push_back(dest->nick); params.push_back(":"+reason); dest->SetOperQuit(operreason); Utils->DoOneToMany(source->nick,"KILL",params); } void ModuleSpanningTree::OnRehash(userrec* user, const std::string ¶meter) { if (!parameter.empty()) { std::deque params; params.push_back(parameter); Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->ServerName, "REHASH", params); // check for self if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter)) { ServerInstance->WriteOpers("*** Remote rehash initiated locally by \002%s\002", user ? user->nick : ServerInstance->Config->ServerName); ServerInstance->RehashServer(); } } Utils->ReadConfiguration(false); InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance); } // note: the protocol does not allow direct umode +o except // via NICK with 8 params. sending OPERTYPE infers +o modechange // locally. void ModuleSpanningTree::OnOper(userrec* user, const std::string &opertype) { if (IS_LOCAL(user)) { std::deque params; params.push_back(opertype); Utils->DoOneToMany(user->nick,"OPERTYPE",params); } } void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason) { if (!source) { /* Server-set lines */ char data[MAXBUF]; snprintf(data,MAXBUF,"%c %s %s %lu %lu :%s", linetype, host.c_str(), ServerInstance->Config->ServerName, (unsigned long)ServerInstance->Time(false), (unsigned long)duration, reason.c_str()); std::deque params; params.push_back(data); Utils->DoOneToMany(ServerInstance->Config->ServerName, "ADDLINE", params); } else { if (IS_LOCAL(source)) { char type[8]; snprintf(type,8,"%cLINE",linetype); std::string stype = type; if (adding) { char sduration[MAXBUF]; snprintf(sduration,MAXBUF,"%ld",duration); std::deque params; params.push_back(host); params.push_back(sduration); params.push_back(":"+reason); Utils->DoOneToMany(source->nick,stype,params); } else { std::deque params; params.push_back(host); Utils->DoOneToMany(source->nick,stype,params); } } } } void ModuleSpanningTree::OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) { OnLine(source,hostmask,true,'G',duration,reason); } void ModuleSpanningTree::OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask) { OnLine(source,ipmask,true,'Z',duration,reason); } void ModuleSpanningTree::OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask) { OnLine(source,nickmask,true,'Q',duration,reason); } void ModuleSpanningTree::OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) { OnLine(source,hostmask,true,'E',duration,reason); } void ModuleSpanningTree::OnDelGLine(userrec* source, const std::string &hostmask) { OnLine(source,hostmask,false,'G',0,""); } void ModuleSpanningTree::OnDelZLine(userrec* source, const std::string &ipmask) { OnLine(source,ipmask,false,'Z',0,""); } void ModuleSpanningTree::OnDelQLine(userrec* source, const std::string &nickmask) { OnLine(source,nickmask,false,'Q',0,""); } void ModuleSpanningTree::OnDelELine(userrec* source, const std::string &hostmask) { OnLine(source,hostmask,false,'E',0,""); } void ModuleSpanningTree::OnMode(userrec* user, void* dest, int target_type, const std::string &text) { if ((IS_LOCAL(user)) && (user->registered == REG_ALL)) { std::deque params; std::string command; if (target_type == TYPE_USER) { userrec* u = (userrec*)dest; params.push_back(u->nick); params.push_back(text); command = "MODE"; } else { chanrec* c = (chanrec*)dest; params.push_back(c->name); params.push_back(ConvToStr(c->age)); params.push_back(text); command = "FMODE"; } Utils->DoOneToMany(user->nick, command, params); } } void ModuleSpanningTree::OnSetAway(userrec* user) { if (IS_LOCAL(user)) { std::deque params; params.push_back(":"+std::string(user->awaymsg)); Utils->DoOneToMany(user->nick,"AWAY",params); } } void ModuleSpanningTree::OnCancelAway(userrec* user) { if (IS_LOCAL(user)) { std::deque params; params.clear(); Utils->DoOneToMany(user->nick,"AWAY",params); } } void ModuleSpanningTree::ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline) { TreeSocket* s = (TreeSocket*)opaque; if (target) { if (target_type == TYPE_USER) { userrec* u = (userrec*)target; s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline); } else { chanrec* c = (chanrec*)target; s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline); } } } void ModuleSpanningTree::ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata) { TreeSocket* s = (TreeSocket*)opaque; if (target) { if (target_type == TYPE_USER) { userrec* u = (userrec*)target; s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+u->nick+" "+extname+" :"+extdata); } else if (target_type == TYPE_CHANNEL) { chanrec* c = (chanrec*)target; s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+c->name+" "+extname+" :"+extdata); } } if (target_type == TYPE_OTHER) { s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA * "+extname+" :"+extdata); } } void ModuleSpanningTree::OnEvent(Event* event) { std::deque* params = (std::deque*)event->GetData(); if (event->GetEventID() == "send_metadata") { if (params->size() < 3) return; (*params)[2] = ":" + (*params)[2]; 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(true))); Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params); } else if (event->GetEventID() == "send_mode") { if (params->size() < 2) return; // Insert the TS value of the object, either userrec or chanrec time_t ourTS = 0; userrec* a = ServerInstance->FindNick((*params)[0]); if (a) { ourTS = a->age; Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params); return; } else { chanrec* a = ServerInstance->FindChan((*params)[0]); if (a) { ourTS = a->age; params->insert(params->begin() + 1,ConvToStr(ourTS)); Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params); } } } else if (event->GetEventID() == "send_mode_explicit") { if (params->size() < 2) return; Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params); } else if (event->GetEventID() == "send_opers") { if (params->size() < 1) return; (*params)[0] = ":" + (*params)[0]; Utils->DoOneToMany(ServerInstance->Config->ServerName,"OPERNOTICE",*params); } else if (event->GetEventID() == "send_modeset") { if (params->size() < 2) return; (*params)[1] = ":" + (*params)[1]; Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODENOTICE",*params); } else if (event->GetEventID() == "send_snoset") { if (params->size() < 2) return; (*params)[1] = ":" + (*params)[1]; Utils->DoOneToMany(ServerInstance->Config->ServerName,"SNONOTICE",*params); } else if (event->GetEventID() == "send_push") { if (params->size() < 2) return; userrec *a = ServerInstance->FindNick((*params)[0]); if (!a) return; (*params)[1] = ":" + (*params)[1]; Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", *params, a->server); } } ModuleSpanningTree::~ModuleSpanningTree() { /* This will also free the listeners */ delete Utils; if (SyncTimer) ServerInstance->Timers->DelTimer(SyncTimer); ServerInstance->Timers->DelTimer(RefreshTimer); ServerInstance->DoneWithInterface("InspSocketHook"); } Version ModuleSpanningTree::GetVersion() { return Version(1,1,0,2,VF_VENDOR,API_VERSION); } void ModuleSpanningTree::Implements(char* List) { List[I_OnPreCommand] = List[I_OnGetServerDescription] = List[I_OnUserInvite] = List[I_OnPostLocalTopicChange] = 1; List[I_OnWallops] = List[I_OnUserNotice] = List[I_OnUserMessage] = List[I_OnBackgroundTimer] = 1; List[I_OnUserJoin] = List[I_OnChangeHost] = List[I_OnChangeName] = List[I_OnUserPart] = List[I_OnUserConnect] = 1; List[I_OnUserQuit] = List[I_OnUserPostNick] = List[I_OnUserKick] = List[I_OnRemoteKill] = List[I_OnRehash] = 1; List[I_OnOper] = List[I_OnAddGLine] = List[I_OnAddZLine] = List[I_OnAddQLine] = List[I_OnAddELine] = 1; List[I_OnDelGLine] = List[I_OnDelZLine] = List[I_OnDelQLine] = List[I_OnDelELine] = List[I_ProtoSendMode] = List[I_OnMode] = 1; List[I_OnStats] = List[I_ProtoSendMetaData] = List[I_OnEvent] = List[I_OnSetAway] = List[I_OnCancelAway] = List[I_OnPostCommand] = 1; } /* It is IMPORTANT that m_spanningtree is the last module in the chain * so that any activity it sees is FINAL, e.g. we arent going to send out * a NICK message before m_cloaking has finished putting the +x on the user, * etc etc. * Therefore, we return PRIORITY_LAST to make sure we end up at the END of * the module call queue. */ Priority ModuleSpanningTree::Prioritize() { return PRIORITY_LAST; } MODULE_INIT(ModuleSpanningTree) \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +/* $ModDesc: Provides a spanning tree server link protocol */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/timesynctimer.h" +#include "m_spanningtree/resolvers.h" +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" +#include "m_spanningtree/rconnect.h" +#include "m_spanningtree/rsquit.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */ + +ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me) + : Module(Me), max_local(0), max_global(0) +{ + ServerInstance->UseInterface("InspSocketHook"); + Utils = new SpanningTreeUtilities(Me, this); + command_rconnect = new cmd_rconnect(ServerInstance, this, Utils); + ServerInstance->AddCommand(command_rconnect); + command_rsquit = new cmd_rsquit(ServerInstance, this, Utils); + ServerInstance->AddCommand(command_rsquit); + if (Utils->EnableTimeSync) + { + SyncTimer = new TimeSyncTimer(ServerInstance, this); + ServerInstance->Timers->AddTimer(SyncTimer); + } + else + SyncTimer = NULL; + + RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils); + ServerInstance->Timers->AddTimer(RefreshTimer); +} + +void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops) +{ + std::string Parent = Utils->TreeRoot->GetName(); + if (Current->GetParent()) + { + Parent = Current->GetParent()->GetName(); + } + for (unsigned int q = 0; q < Current->ChildCount(); q++) + { + if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))) + { + if (*user->oper) + { + ShowLinks(Current->GetChild(q),user,hops+1); + } + } + else + { + ShowLinks(Current->GetChild(q),user,hops+1); + } + } + /* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */ + if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!IS_OPER(user))) + return; + /* Or if the server is hidden and they're not an oper */ + else if ((Current->Hidden) && (!IS_OPER(user))) + return; + + user->WriteServ("364 %s %s %s :%d %s", user->nick,Current->GetName().c_str(), + (Utils->FlatLinks && (!IS_OPER(user))) ? ServerInstance->Config->ServerName : Parent.c_str(), + (Utils->FlatLinks && (!IS_OPER(user))) ? 0 : hops, + Current->GetDesc().c_str()); +} + +int ModuleSpanningTree::CountLocalServs() +{ + return Utils->TreeRoot->ChildCount(); +} + +int ModuleSpanningTree::CountServs() +{ + return Utils->serverlist.size(); +} + +void ModuleSpanningTree::HandleLinks(const char** parameters, int pcnt, userrec* user) +{ + ShowLinks(Utils->TreeRoot,user,0); + user->WriteServ("365 %s * :End of /LINKS list.",user->nick); + return; +} + +void ModuleSpanningTree::HandleLusers(const char** parameters, int pcnt, userrec* user) +{ + unsigned int n_users = ServerInstance->UserCount(); + + /* Only update these when someone wants to see them, more efficient */ + if ((unsigned int)ServerInstance->LocalUserCount() > max_local) + max_local = ServerInstance->LocalUserCount(); + if (n_users > max_global) + max_global = n_users; + + unsigned int ulined_count = 0; + unsigned int ulined_local_count = 0; + + /* If ulined are hidden and we're not an oper, count the number of ulined servers hidden, + * locally and globally (locally means directly connected to us) + */ + if ((Utils->HideULines) && (!*user->oper)) + { + for (server_hash::iterator q = Utils->serverlist.begin(); q != Utils->serverlist.end(); q++) + { + if (ServerInstance->ULine(q->second->GetName().c_str())) + { + ulined_count++; + if (q->second->GetParent() == Utils->TreeRoot) + ulined_local_count++; + } + } + } + user->WriteServ("251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-ServerInstance->InvisibleUserCount(),ServerInstance->InvisibleUserCount(),ulined_count ? this->CountServs() - ulined_count : this->CountServs()); + if (ServerInstance->OperCount()) + user->WriteServ("252 %s %d :operator(s) online",user->nick,ServerInstance->OperCount()); + if (ServerInstance->UnregisteredUserCount()) + user->WriteServ("253 %s %d :unknown connections",user->nick,ServerInstance->UnregisteredUserCount()); + if (ServerInstance->ChannelCount()) + user->WriteServ("254 %s %d :channels formed",user->nick,ServerInstance->ChannelCount()); + user->WriteServ("255 %s :I have %d clients and %d servers",user->nick,ServerInstance->LocalUserCount(),ulined_local_count ? this->CountLocalServs() - ulined_local_count : this->CountLocalServs()); + user->WriteServ("265 %s :Current Local Users: %d Max: %d",user->nick,ServerInstance->LocalUserCount(),max_local); + user->WriteServ("266 %s :Current Global Users: %d Max: %d",user->nick,n_users,max_global); + return; +} + +std::string ModuleSpanningTree::TimeToStr(time_t secs) +{ + time_t mins_up = secs / 60; + time_t hours_up = mins_up / 60; + time_t days_up = hours_up / 24; + secs = secs % 60; + mins_up = mins_up % 60; + hours_up = hours_up % 24; + return ((days_up ? (ConvToStr(days_up) + "d") : std::string("")) + + (hours_up ? (ConvToStr(hours_up) + "h") : std::string("")) + + (mins_up ? (ConvToStr(mins_up) + "m") : std::string("")) + + ConvToStr(secs) + "s"); +} + +const std::string ModuleSpanningTree::MapOperInfo(TreeServer* Current) +{ + time_t secs_up = ServerInstance->Time() - Current->age; + return (" [Up: " + TimeToStr(secs_up) + " Lag: "+ConvToStr(Current->rtt)+"s]"); +} + +// WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS. +void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][128], float &totusers, float &totservers) +{ + if (line < 128) + { + for (int t = 0; t < depth; t++) + { + matrix[line][t] = ' '; + } + // For Aligning, we need to work out exactly how deep this thing is, and produce + // a 'Spacer' String to compensate. + char spacer[40]; + memset(spacer,' ',40); + if ((40 - Current->GetName().length() - depth) > 1) { + spacer[40 - Current->GetName().length() - depth] = '\0'; + } + else + { + spacer[5] = '\0'; + } + float percent; + char text[128]; + /* Neat and tidy default values, as we're dealing with a matrix not a simple string */ + memset(text, 0, 128); + + if (ServerInstance->clientlist->size() == 0) { + // If there are no users, WHO THE HELL DID THE /MAP?!?!?! + percent = 0; + } + else + { + percent = ((float)Current->GetUserCount() / (float)ServerInstance->clientlist->size()) * 100; + } + const std::string operdata = IS_OPER(user) ? MapOperInfo(Current) : ""; + snprintf(text, 126, "%s %s%5d [%5.2f%%]%s", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent, operdata.c_str()); + totusers += Current->GetUserCount(); + totservers++; + strlcpy(&matrix[line][depth],text,126); + line++; + for (unsigned int q = 0; q < Current->ChildCount(); q++) + { + if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))) + { + if (*user->oper) + { + ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); + } + } + else + { + ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers); + } + } + } +} + +int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* user) +{ + if (pcnt > 0) + { + if (match(ServerInstance->Config->ServerName, parameters[0])) + return 0; + + /* Remote MOTD, the server is within the 1st parameter */ + std::deque params; + params.push_back(parameters[0]); + /* Send it out remotely, generate no reply yet */ + TreeServer* s = Utils->FindServerMask(parameters[0]); + if (s) + { + params[0] = s->GetName(); + Utils->DoOneToOne(user->nick, "MOTD", params, s->GetName()); + } + else + user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]); + return 1; + } + return 0; +} + +int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec* user) +{ + if (pcnt > 0) + { + if (match(ServerInstance->Config->ServerName, parameters[0])) + return 0; + + /* Remote ADMIN, the server is within the 1st parameter */ + std::deque params; + params.push_back(parameters[0]); + /* Send it out remotely, generate no reply yet */ + TreeServer* s = Utils->FindServerMask(parameters[0]); + if (s) + { + params[0] = s->GetName(); + Utils->DoOneToOne(user->nick, "ADMIN", params, s->GetName()); + } + else + user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]); + return 1; + } + return 0; +} + +int ModuleSpanningTree::HandleModules(const char** parameters, int pcnt, userrec* user) +{ + if (pcnt > 0) + { + if (match(ServerInstance->Config->ServerName, parameters[0])) + return 0; + + std::deque params; + params.push_back(parameters[0]); + TreeServer* s = Utils->FindServerMask(parameters[0]); + if (s) + { + params[0] = s->GetName(); + Utils->DoOneToOne(user->nick, "MODULES", params, s->GetName()); + } + else + user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]); + return 1; + } + return 0; +} + +int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, userrec* user) +{ + if (pcnt > 1) + { + if (match(ServerInstance->Config->ServerName, parameters[1])) + return 0; + + /* Remote STATS, the server is within the 2nd parameter */ + std::deque params; + params.push_back(parameters[0]); + params.push_back(parameters[1]); + /* Send it out remotely, generate no reply yet */ + + TreeServer* s = Utils->FindServerMask(parameters[1]); + if (s) + { + params[1] = s->GetName(); + Utils->DoOneToOne(user->nick, "STATS", params, s->GetName()); + } + else + { + user->WriteServ( "402 %s %s :No such server", user->nick, parameters[1]); + } + return 1; + } + return 0; +} + +// Ok, prepare to be confused. +// After much mulling over how to approach this, it struck me that +// the 'usual' way of doing a /MAP isnt the best way. Instead of +// keeping track of a ton of ascii characters, and line by line +// under recursion working out where to place them using multiplications +// and divisons, we instead render the map onto a backplane of characters +// (a character matrix), then draw the branches as a series of "L" shapes +// from the nodes. This is not only friendlier on CPU it uses less stack. +void ModuleSpanningTree::HandleMap(const char** parameters, int pcnt, userrec* user) +{ + // This array represents a virtual screen which we will + // "scratch" draw to, as the console device of an irc + // client does not provide for a proper terminal. + float totusers = 0; + float totservers = 0; + char matrix[128][128]; + for (unsigned int t = 0; t < 128; t++) + { + matrix[t][0] = '\0'; + } + line = 0; + // The only recursive bit is called here. + 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 + // the character matrix deeper, 128 rows taking 10k of memory. + for (int l = 1; l < line; l++) + { + // scan across the line looking for the start of the + // servername (the recursive part of the algorithm has placed + // the servers at indented positions depending on what they + // are related to) + int first_nonspace = 0; + while (matrix[l][first_nonspace] == ' ') + { + first_nonspace++; + } + first_nonspace--; + // Draw the `- (corner) section: this may be overwritten by + // another L shape passing along the same vertical pane, becoming + // a |- (branch) section instead. + matrix[l][first_nonspace] = '-'; + matrix[l][first_nonspace-1] = '`'; + int l2 = l - 1; + // Draw upwards until we hit the parent server, causing possibly + // other corners (`-) to become branches (|-) + while ((matrix[l2][first_nonspace-1] == ' ') || (matrix[l2][first_nonspace-1] == '`')) + { + matrix[l2][first_nonspace-1] = '|'; + l2--; + } + } + // dump the whole lot to the user. This is the easy bit, honest. + for (int t = 0; t < line; t++) + { + user->WriteServ("006 %s :%s",user->nick,&matrix[t][0]); + } + float avg_users = totusers / totservers; + user->WriteServ("270 %s :%.0f server%s and %.0f user%s, average %.2f users per server",user->nick,totservers,(totservers > 1 ? "s" : ""),totusers,(totusers > 1 ? "s" : ""),avg_users); + user->WriteServ("007 %s :End of /MAP",user->nick); + return; +} + +int ModuleSpanningTree::HandleSquit(const char** parameters, int pcnt, userrec* user) +{ + TreeServer* s = Utils->FindServerMask(parameters[0]); + if (s) + { + 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; + } + TreeSocket* sock = s->GetSocket(); + if (sock) + { + ServerInstance->SNO->WriteToSnoMask('l',"SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick); + sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost()); + ServerInstance->SE->DelFd(sock); + sock->Close(); + } + else + { + if (IS_LOCAL(user)) + user->WriteServ("NOTICE %s :*** WARNING: Using SQUIT to split remote servers is deprecated. Please use RSQUIT instead.",user->nick); + } + } + else + { + user->WriteServ("NOTICE %s :*** SQUIT: The server \002%s\002 does not exist on the network.",user->nick,parameters[0]); + } + return 1; +} + +int ModuleSpanningTree::HandleTime(const char** parameters, int pcnt, userrec* user) +{ + if ((IS_LOCAL(user)) && (pcnt)) + { + TreeServer* found = Utils->FindServerMask(parameters[0]); + if (found) + { + // we dont' override for local server + if (found == Utils->TreeRoot) + return 0; + + std::deque params; + params.push_back(found->GetName()); + params.push_back(user->nick); + Utils->DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName()); + } + else + { + user->WriteServ("402 %s %s :No such server",user->nick,parameters[0]); + } + } + return 1; +} + +int ModuleSpanningTree::HandleRemoteWhois(const char** parameters, int pcnt, userrec* user) +{ + if ((IS_LOCAL(user)) && (pcnt > 1)) + { + userrec* remote = ServerInstance->FindNick(parameters[1]); + if ((remote) && (remote->GetFd() < 0)) + { + std::deque params; + params.push_back(parameters[1]); + Utils->DoOneToOne(user->nick,"IDLE",params,remote->server); + return 1; + } + else if (!remote) + { + user->WriteServ("401 %s %s :No such nick/channel",user->nick, parameters[1]); + user->WriteServ("318 %s %s :End of /WHOIS list.",user->nick, parameters[1]); + return 1; + } + } + return 0; +} + +void ModuleSpanningTree::DoPingChecks(time_t curtime) +{ + for (unsigned int j = 0; j < Utils->TreeRoot->ChildCount(); j++) + { + TreeServer* serv = Utils->TreeRoot->GetChild(j); + TreeSocket* sock = serv->GetSocket(); + if (sock) + { + if (curtime >= serv->NextPingTime()) + { + if (serv->AnsweredLastPing()) + { + sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName()); + serv->SetNextPingTime(curtime + 60); + serv->LastPing = curtime; + serv->Warned = false; + } + else + { + /* they didnt answer, boot them */ + sock->SendError("Ping timeout"); + sock->Squit(serv,"Ping timeout"); + /*** XXX SOCKET CULL ***/ + return; + } + } + else if ((Utils->PingWarnTime) && (!serv->Warned) && (curtime >= serv->NextPingTime() - (60 - Utils->PingWarnTime)) && (!serv->AnsweredLastPing())) + { + /* The server hasnt responded, send a warning to opers */ + ServerInstance->SNO->WriteToSnoMask('l',"Server \002%s\002 has not responded to PING for %d seconds, high latency.", serv->GetName().c_str(), Utils->PingWarnTime); + serv->Warned = true; + } + } + } + + /* Cancel remote burst mode on any servers which still have it enabled due to latency/lack of data. + * This prevents lost REMOTECONNECT notices + */ + for (server_hash::iterator i = Utils->serverlist.begin(); i != Utils->serverlist.end(); i++) + Utils->SetRemoteBursting(i->second, false); +} + +void ModuleSpanningTree::ConnectServer(Link* x) +{ + bool ipvalid = true; + QueryType start_type = DNS_QUERY_A; +#ifdef IPV6 + start_type = DNS_QUERY_AAAA; + if (strchr(x->IPAddr.c_str(),':')) + { + in6_addr n; + if (inet_pton(AF_INET6, x->IPAddr.c_str(), &n) < 1) + ipvalid = false; + } + else +#endif + { + in_addr n; + if (inet_aton(x->IPAddr.c_str(),&n) < 1) + ipvalid = false; + } + + /* Do we already have an IP? If so, no need to resolve it. */ + if (ipvalid) + { + /* Gave a hook, but it wasnt one we know */ + if ((!x->Hook.empty()) && (Utils->hooks.find(x->Hook.c_str()) == Utils->hooks.end())) + return; + TreeSocket* newsocket = new TreeSocket(Utils, ServerInstance, x->IPAddr,x->Port,false,x->Timeout ? x->Timeout : 10,x->Name.c_str(), x->Bind, x->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]); + if (newsocket->GetFd() > -1) + { + /* Handled automatically on success */ + } + else + { + ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno)); + delete newsocket; + Utils->DoFailOver(x); + } + } + else + { + try + { + bool cached; + ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached, start_type); + ServerInstance->AddResolver(snr, cached); + } + catch (ModuleException& e) + { + ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason()); + Utils->DoFailOver(x); + } + } +} + +void ModuleSpanningTree::AutoConnectServers(time_t curtime) +{ + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) + { + if ((x->AutoConnect) && (curtime >= x->NextConnectTime)) + { + x->NextConnectTime = curtime + x->AutoConnect; + TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str()); + if (x->FailOver.length()) + { + TreeServer* CheckFailOver = Utils->FindServer(x->FailOver.c_str()); + if (CheckFailOver) + { + /* The failover for this server is currently a member of the network. + * The failover probably succeeded, where the main link did not. + * Don't try the main link until the failover is gone again. + */ + continue; + } + } + if (!CheckDupe) + { + // an autoconnected server is not connected. Check if its time to connect it + ServerInstance->SNO->WriteToSnoMask('l',"AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect); + this->ConnectServer(&(*x)); + } + } + } +} + +int ModuleSpanningTree::HandleVersion(const char** parameters, int pcnt, userrec* user) +{ + // we've already checked if pcnt > 0, so this is safe + 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 == Utils->TreeRoot) + { + ServerInstance->Config->Send005(user); + } + } + else + { + user->WriteServ("402 %s %s :No such server",user->nick,parameters[0]); + } + return 1; +} + +int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec* user) +{ + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) + { + if (ServerInstance->MatchText(x->Name.c_str(),parameters[0])) + { + 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); + ConnectServer(&(*x)); + return 1; + } + else + { + user->WriteServ("NOTICE %s :*** CONNECT: Server \002%s\002 already exists on the network and is connected via \002%s\002",user->nick,x->Name.c_str(),CheckDupe->GetParent()->GetName().c_str()); + return 1; + } + } + } + user->WriteServ("NOTICE %s :*** CONNECT: No server matching \002%s\002 could be found in the config file.",user->nick,parameters[0]); + return 1; +} + +void ModuleSpanningTree::BroadcastTimeSync() +{ + if (Utils->MasterTime) + { + std::deque params; + params.push_back(ConvToStr(ServerInstance->Time(false))); + params.push_back("FORCE"); + Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params); + } +} + +int ModuleSpanningTree::OnStats(char statschar, userrec* user, string_list &results) +{ + if ((statschar == 'c') || (statschar == 'n')) + { + for (unsigned int i = 0; i < Utils->LinkBlocks.size(); i++) + { + results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" "+statschar+" *@"+(Utils->LinkBlocks[i].HiddenFromStats ? "" : Utils->LinkBlocks[i].IPAddr)+" * "+Utils->LinkBlocks[i].Name.c_str()+" "+ConvToStr(Utils->LinkBlocks[i].Port)+" "+(Utils->LinkBlocks[i].Hook.empty() ? "plaintext" : Utils->LinkBlocks[i].Hook)+" "+(Utils->LinkBlocks[i].AutoConnect ? 'a' : '-')+'s'); + if (statschar == 'c') + 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',"%s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host); + return 1; + } + + if (statschar == 'p') + { + /* show all server ports, after showing client ports. -- w00t */ + + for (unsigned int i = 0; i < Utils->Bindings.size(); i++) + { + std::string ip = Utils->Bindings[i]->IP; + if (ip.empty()) + ip = "*"; + + std::string transport("plaintext"); + if (Utils->Bindings[i]->GetHook()) + transport = InspSocketNameRequest(this, Utils->Bindings[i]->GetHook()).Send(); + + results.push_back(ConvToStr(ServerInstance->Config->ServerName) + " 249 "+user->nick+" :" + ip + ":" + ConvToStr(Utils->Bindings[i]->port)+ + " (server, " + transport + ")"); + } + } + return 0; +} + +int ModuleSpanningTree::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) + return 0; + + if (command == "CONNECT") + { + return this->HandleConnect(parameters,pcnt,user); + } + else if (command == "STATS") + { + return this->HandleStats(parameters,pcnt,user); + } + else if (command == "MOTD") + { + return this->HandleMotd(parameters,pcnt,user); + } + else if (command == "ADMIN") + { + return this->HandleAdmin(parameters,pcnt,user); + } + else if (command == "SQUIT") + { + return this->HandleSquit(parameters,pcnt,user); + } + else if (command == "MAP") + { + this->HandleMap(parameters,pcnt,user); + return 1; + } + else if ((command == "TIME") && (pcnt > 0)) + { + return this->HandleTime(parameters,pcnt,user); + } + else if (command == "LUSERS") + { + this->HandleLusers(parameters,pcnt,user); + return 1; + } + else if (command == "LINKS") + { + this->HandleLinks(parameters,pcnt,user); + return 1; + } + else if (command == "WHOIS") + { + if (pcnt > 1) + { + // remote whois + return this->HandleRemoteWhois(parameters,pcnt,user); + } + } + else if ((command == "VERSION") && (pcnt > 0)) + { + this->HandleVersion(parameters,pcnt,user); + return 1; + } + else if ((command == "MODULES") && (pcnt > 0)) + { + return this->HandleModules(parameters,pcnt,user); + } + return 0; +} + +void ModuleSpanningTree::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))) + { + // this bit of code cleverly routes all module commands + // to all remote severs *automatically* so that modules + // can just handle commands locally, without having + // to have any special provision in place for remote + // commands and linking protocols. + std::deque params; + params.clear(); + for (int j = 0; j < pcnt; j++) + { + if (strchr(parameters[j],' ')) + { + params.push_back(":" + std::string(parameters[j])); + } + else + { + params.push_back(std::string(parameters[j])); + } + } + Utils->DoOneToMany(user->nick,command,params); + } +} + +void ModuleSpanningTree::OnGetServerDescription(const std::string &servername,std::string &description) +{ + TreeServer* s = Utils->FindServer(servername); + if (s) + { + description = s->GetDesc(); + } +} + +void ModuleSpanningTree::OnUserInvite(userrec* source,userrec* dest,chanrec* channel) +{ + if (IS_LOCAL(source)) + { + std::deque params; + params.push_back(dest->nick); + params.push_back(channel->name); + Utils->DoOneToMany(source->nick,"INVITE",params); + } +} + +void ModuleSpanningTree::OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic) +{ + std::deque params; + params.push_back(chan->name); + params.push_back(":"+topic); + Utils->DoOneToMany(user->nick,"TOPIC",params); +} + +void ModuleSpanningTree::OnWallops(userrec* user, const std::string &text) +{ + if (IS_LOCAL(user)) + { + std::deque params; + params.push_back(":"+text); + Utils->DoOneToMany(user->nick,"WALLOPS",params); + } +} + +void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list) +{ + if (target_type == TYPE_USER) + { + userrec* d = (userrec*)dest; + if ((d->GetFd() < 0) && (IS_LOCAL(user))) + { + std::deque params; + params.clear(); + params.push_back(d->nick); + params.push_back(":"+text); + Utils->DoOneToOne(user->nick,"NOTICE",params,d->server); + } + } + else if (target_type == TYPE_CHANNEL) + { + if (IS_LOCAL(user)) + { + chanrec *c = (chanrec*)dest; + if (c) + { + std::string cname = c->name; + if (status) + cname = status + cname; + TreeServerList list; + Utils->GetListOfServersForChannel(c,list,status,exempt_list); + for (TreeServerList::iterator i = list.begin(); i != list.end(); i++) + { + TreeSocket* Sock = i->second->GetSocket(); + if (Sock) + Sock->WriteLine(":"+std::string(user->nick)+" NOTICE "+cname+" :"+text); + } + } + } + } + else if (target_type == TYPE_SERVER) + { + if (IS_LOCAL(user)) + { + char* target = (char*)dest; + std::deque par; + par.push_back(target); + par.push_back(":"+text); + Utils->DoOneToMany(user->nick,"NOTICE",par); + } + } +} + +void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list) +{ + if (target_type == TYPE_USER) + { + // route private messages which are targetted at clients only to the server + // which needs to receive them + userrec* d = (userrec*)dest; + if ((d->GetFd() < 0) && (IS_LOCAL(user))) + { + std::deque params; + params.clear(); + params.push_back(d->nick); + params.push_back(":"+text); + Utils->DoOneToOne(user->nick,"PRIVMSG",params,d->server); + } + } + else if (target_type == TYPE_CHANNEL) + { + if (IS_LOCAL(user)) + { + chanrec *c = (chanrec*)dest; + if (c) + { + std::string cname = c->name; + if (status) + cname = status + cname; + TreeServerList list; + Utils->GetListOfServersForChannel(c,list,status,exempt_list); + for (TreeServerList::iterator i = list.begin(); i != list.end(); i++) + { + TreeSocket* Sock = i->second->GetSocket(); + if (Sock) + Sock->WriteLine(":"+std::string(user->nick)+" PRIVMSG "+cname+" :"+text); + } + } + } + } + else if (target_type == TYPE_SERVER) + { + if (IS_LOCAL(user)) + { + char* target = (char*)dest; + std::deque par; + par.push_back(target); + par.push_back(":"+text); + Utils->DoOneToMany(user->nick,"PRIVMSG",par); + } + } +} + +void ModuleSpanningTree::OnBackgroundTimer(time_t curtime) +{ + AutoConnectServers(curtime); + DoPingChecks(curtime); +} + +void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel, bool &silent) +{ + // Only do this for local users + if (IS_LOCAL(user)) + { + if (channel->GetUserCounter() == 1) + { + std::deque 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.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); + /* First user in, sync the modes for the channel */ + params.pop_back(); + params.push_back(channel->ChanModes(true)); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params); + } + else + { + std::deque params; + params.push_back(channel->name); + params.push_back(ConvToStr(channel->age)); + Utils->DoOneToMany(user->nick,"JOIN",params); + } + } +} + +void ModuleSpanningTree::OnChangeHost(userrec* user, const std::string &newhost) +{ + // only occurs for local clients + if (user->registered != REG_ALL) + return; + std::deque params; + params.push_back(newhost); + Utils->DoOneToMany(user->nick,"FHOST",params); +} + +void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos) +{ + // only occurs for local clients + if (user->registered != REG_ALL) + return; + std::deque params; + params.push_back(gecos); + Utils->DoOneToMany(user->nick,"FNAME",params); +} + +void ModuleSpanningTree::OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage, bool &silent) +{ + if (IS_LOCAL(user)) + { + std::deque params; + params.push_back(channel->name); + if (!partmessage.empty()) + params.push_back(":"+partmessage); + Utils->DoOneToMany(user->nick,"PART",params); + } +} + +void ModuleSpanningTree::OnUserConnect(userrec* user) +{ + char agestr[MAXBUF]; + if (IS_LOCAL(user)) + { + std::deque params; + snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age); + params.push_back(agestr); + params.push_back(user->nick); + params.push_back(user->host); + params.push_back(user->dhost); + params.push_back(user->ident); + params.push_back("+"+std::string(user->FormatModes())); + params.push_back(user->GetIPString()); + params.push_back(":"+std::string(user->fullname)); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"NICK",params); + // User is Local, change needs to be reflected! + TreeServer* SourceServer = Utils->FindServer(user->server); + if (SourceServer) + { + SourceServer->AddUserCount(); + } + } +} + +void ModuleSpanningTree::OnUserQuit(userrec* user, const std::string &reason, const std::string &oper_message) +{ + if ((IS_LOCAL(user)) && (user->registered == REG_ALL)) + { + std::deque params; + + if (oper_message != reason) + { + params.push_back(":"+oper_message); + Utils->DoOneToMany(user->nick,"OPERQUIT",params); + } + params.clear(); + params.push_back(":"+reason); + Utils->DoOneToMany(user->nick,"QUIT",params); + } + // Regardless, We need to modify the user Counts.. + TreeServer* SourceServer = Utils->FindServer(user->server); + if (SourceServer) + { + SourceServer->DelUserCount(); + } +} + +void ModuleSpanningTree::OnUserPostNick(userrec* user, const std::string &oldnick) +{ + if (IS_LOCAL(user)) + { + std::deque params; + params.push_back(user->nick); + Utils->DoOneToMany(oldnick,"NICK",params); + } +} + +void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason, bool &silent) +{ + if ((source) && (IS_LOCAL(source))) + { + std::deque params; + params.push_back(chan->name); + params.push_back(user->nick); + params.push_back(":"+reason); + Utils->DoOneToMany(source->nick,"KICK",params); + } + else if (!source) + { + std::deque params; + params.push_back(chan->name); + params.push_back(user->nick); + params.push_back(":"+reason); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params); + } +} + +void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason, const std::string &operreason) +{ + std::deque params; + params.push_back(":"+reason); + Utils->DoOneToMany(dest->nick,"OPERQUIT",params); + params.clear(); + params.push_back(dest->nick); + params.push_back(":"+reason); + dest->SetOperQuit(operreason); + Utils->DoOneToMany(source->nick,"KILL",params); +} + +void ModuleSpanningTree::OnRehash(userrec* user, const std::string ¶meter) +{ + if (!parameter.empty()) + { + std::deque params; + params.push_back(parameter); + Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->ServerName, "REHASH", params); + // check for self + if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter)) + { + ServerInstance->WriteOpers("*** Remote rehash initiated locally by \002%s\002", user ? user->nick : ServerInstance->Config->ServerName); + ServerInstance->RehashServer(); + } + } + Utils->ReadConfiguration(false); + InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance); +} + +// note: the protocol does not allow direct umode +o except +// via NICK with 8 params. sending OPERTYPE infers +o modechange +// locally. +void ModuleSpanningTree::OnOper(userrec* user, const std::string &opertype) +{ + if (IS_LOCAL(user)) + { + std::deque params; + params.push_back(opertype); + Utils->DoOneToMany(user->nick,"OPERTYPE",params); + } +} + +void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason) +{ + if (!source) + { + /* Server-set lines */ + char data[MAXBUF]; + snprintf(data,MAXBUF,"%c %s %s %lu %lu :%s", linetype, host.c_str(), ServerInstance->Config->ServerName, (unsigned long)ServerInstance->Time(false), + (unsigned long)duration, reason.c_str()); + std::deque params; + params.push_back(data); + Utils->DoOneToMany(ServerInstance->Config->ServerName, "ADDLINE", params); + } + else + { + if (IS_LOCAL(source)) + { + char type[8]; + snprintf(type,8,"%cLINE",linetype); + std::string stype = type; + if (adding) + { + char sduration[MAXBUF]; + snprintf(sduration,MAXBUF,"%ld",duration); + std::deque params; + params.push_back(host); + params.push_back(sduration); + params.push_back(":"+reason); + Utils->DoOneToMany(source->nick,stype,params); + } + else + { + std::deque params; + params.push_back(host); + Utils->DoOneToMany(source->nick,stype,params); + } + } + } +} + +void ModuleSpanningTree::OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) +{ + OnLine(source,hostmask,true,'G',duration,reason); +} + +void ModuleSpanningTree::OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask) +{ + OnLine(source,ipmask,true,'Z',duration,reason); +} + +void ModuleSpanningTree::OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask) +{ + OnLine(source,nickmask,true,'Q',duration,reason); +} + +void ModuleSpanningTree::OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) +{ + OnLine(source,hostmask,true,'E',duration,reason); +} + +void ModuleSpanningTree::OnDelGLine(userrec* source, const std::string &hostmask) +{ + OnLine(source,hostmask,false,'G',0,""); +} + +void ModuleSpanningTree::OnDelZLine(userrec* source, const std::string &ipmask) +{ + OnLine(source,ipmask,false,'Z',0,""); +} + +void ModuleSpanningTree::OnDelQLine(userrec* source, const std::string &nickmask) +{ + OnLine(source,nickmask,false,'Q',0,""); +} + +void ModuleSpanningTree::OnDelELine(userrec* source, const std::string &hostmask) +{ + OnLine(source,hostmask,false,'E',0,""); +} + +void ModuleSpanningTree::OnMode(userrec* user, void* dest, int target_type, const std::string &text) +{ + if ((IS_LOCAL(user)) && (user->registered == REG_ALL)) + { + std::deque params; + std::string command; + + if (target_type == TYPE_USER) + { + userrec* u = (userrec*)dest; + params.push_back(u->nick); + params.push_back(text); + command = "MODE"; + } + else + { + chanrec* c = (chanrec*)dest; + params.push_back(c->name); + params.push_back(ConvToStr(c->age)); + params.push_back(text); + command = "FMODE"; + } + Utils->DoOneToMany(user->nick, command, params); + } +} + +void ModuleSpanningTree::OnSetAway(userrec* user) +{ + if (IS_LOCAL(user)) + { + std::deque params; + params.push_back(":"+std::string(user->awaymsg)); + Utils->DoOneToMany(user->nick,"AWAY",params); + } +} + +void ModuleSpanningTree::OnCancelAway(userrec* user) +{ + if (IS_LOCAL(user)) + { + std::deque params; + params.clear(); + Utils->DoOneToMany(user->nick,"AWAY",params); + } +} + +void ModuleSpanningTree::ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline) +{ + TreeSocket* s = (TreeSocket*)opaque; + if (target) + { + if (target_type == TYPE_USER) + { + userrec* u = (userrec*)target; + s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline); + } + else + { + chanrec* c = (chanrec*)target; + s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline); + } + } +} + +void ModuleSpanningTree::ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata) +{ + TreeSocket* s = (TreeSocket*)opaque; + if (target) + { + if (target_type == TYPE_USER) + { + userrec* u = (userrec*)target; + s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+u->nick+" "+extname+" :"+extdata); + } + else if (target_type == TYPE_CHANNEL) + { + chanrec* c = (chanrec*)target; + s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+c->name+" "+extname+" :"+extdata); + } + } + if (target_type == TYPE_OTHER) + { + s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA * "+extname+" :"+extdata); + } +} + +void ModuleSpanningTree::OnEvent(Event* event) +{ + std::deque* params = (std::deque*)event->GetData(); + if (event->GetEventID() == "send_metadata") + { + if (params->size() < 3) + return; + (*params)[2] = ":" + (*params)[2]; + 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(true))); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params); + } + else if (event->GetEventID() == "send_mode") + { + if (params->size() < 2) + return; + // Insert the TS value of the object, either userrec or chanrec + time_t ourTS = 0; + userrec* a = ServerInstance->FindNick((*params)[0]); + if (a) + { + ourTS = a->age; + Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params); + return; + } + else + { + chanrec* a = ServerInstance->FindChan((*params)[0]); + if (a) + { + ourTS = a->age; + params->insert(params->begin() + 1,ConvToStr(ourTS)); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params); + } + } + } + else if (event->GetEventID() == "send_mode_explicit") + { + if (params->size() < 2) + return; + Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params); + } + else if (event->GetEventID() == "send_opers") + { + if (params->size() < 1) + return; + (*params)[0] = ":" + (*params)[0]; + Utils->DoOneToMany(ServerInstance->Config->ServerName,"OPERNOTICE",*params); + } + else if (event->GetEventID() == "send_modeset") + { + if (params->size() < 2) + return; + (*params)[1] = ":" + (*params)[1]; + Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODENOTICE",*params); + } + else if (event->GetEventID() == "send_snoset") + { + if (params->size() < 2) + return; + (*params)[1] = ":" + (*params)[1]; + Utils->DoOneToMany(ServerInstance->Config->ServerName,"SNONOTICE",*params); + } + else if (event->GetEventID() == "send_push") + { + if (params->size() < 2) + return; + + userrec *a = ServerInstance->FindNick((*params)[0]); + + if (!a) + return; + + (*params)[1] = ":" + (*params)[1]; + Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", *params, a->server); + } +} + +ModuleSpanningTree::~ModuleSpanningTree() +{ + /* This will also free the listeners */ + delete Utils; + if (SyncTimer) + ServerInstance->Timers->DelTimer(SyncTimer); + + ServerInstance->Timers->DelTimer(RefreshTimer); + + ServerInstance->DoneWithInterface("InspSocketHook"); +} + +Version ModuleSpanningTree::GetVersion() +{ + return Version(1,1,0,2,VF_VENDOR,API_VERSION); +} + +void ModuleSpanningTree::Implements(char* List) +{ + List[I_OnPreCommand] = List[I_OnGetServerDescription] = List[I_OnUserInvite] = List[I_OnPostLocalTopicChange] = 1; + List[I_OnWallops] = List[I_OnUserNotice] = List[I_OnUserMessage] = List[I_OnBackgroundTimer] = 1; + List[I_OnUserJoin] = List[I_OnChangeHost] = List[I_OnChangeName] = List[I_OnUserPart] = List[I_OnUserConnect] = 1; + List[I_OnUserQuit] = List[I_OnUserPostNick] = List[I_OnUserKick] = List[I_OnRemoteKill] = List[I_OnRehash] = 1; + List[I_OnOper] = List[I_OnAddGLine] = List[I_OnAddZLine] = List[I_OnAddQLine] = List[I_OnAddELine] = 1; + List[I_OnDelGLine] = List[I_OnDelZLine] = List[I_OnDelQLine] = List[I_OnDelELine] = List[I_ProtoSendMode] = List[I_OnMode] = 1; + List[I_OnStats] = List[I_ProtoSendMetaData] = List[I_OnEvent] = List[I_OnSetAway] = List[I_OnCancelAway] = List[I_OnPostCommand] = 1; +} + +/* It is IMPORTANT that m_spanningtree is the last module in the chain + * so that any activity it sees is FINAL, e.g. we arent going to send out + * a NICK message before m_cloaking has finished putting the +x on the user, + * etc etc. + * Therefore, we return PRIORITY_LAST to make sure we end up at the END of + * the module call queue. + */ +Priority ModuleSpanningTree::Prioritize() +{ + return PRIORITY_LAST; +} + +MODULE_INIT(ModuleSpanningTree) + diff --git a/src/modules/m_spanningtree/main.h b/src/modules/m_spanningtree/main.h index 5bfb73e6a..c184ef076 100644 --- a/src/modules/m_spanningtree/main.h +++ b/src/modules/m_spanningtree/main.h @@ -1 +1,198 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __ST_MAIN__ #define __ST_MAIN__ #include "inspircd.h" #include "modules.h" /** If you make a change which breaks the protocol, increment this. * If you completely change the protocol, completely change the number. * * IMPORTANT: If you make changes, document your changes here, without fail: * http://www.inspircd.org/wiki/List_of_protocol_changes_between_versions * * Failure to document your protocol changes will result in a painfully * painful death by pain. You have been warned. */ const long ProtocolVersion = 1105; /** Forward declarations */ class cmd_rconnect; class cmd_rsquit; class SpanningTreeUtilities; class TimeSyncTimer; class CacheRefreshTimer; class TreeServer; class Link; /** This is the main class for the spanningtree module */ class ModuleSpanningTree : public Module { int line; int NumServers; unsigned int max_local; unsigned int max_global; cmd_rconnect* command_rconnect; cmd_rsquit* command_rsquit; SpanningTreeUtilities* Utils; public: /** Timer for clock syncs */ TimeSyncTimer *SyncTimer; CacheRefreshTimer *RefreshTimer; /** Constructor */ ModuleSpanningTree(InspIRCd* Me); /** Shows /LINKS */ void ShowLinks(TreeServer* Current, userrec* user, int hops); /** Counts local servers */ int CountLocalServs(); /** Counts local and remote servers */ int CountServs(); /** Handle LINKS command */ void HandleLinks(const char** parameters, int pcnt, userrec* user); /** Handle LUSERS command */ void HandleLusers(const char** parameters, int pcnt, userrec* user); /** Show MAP output to a user (recursive) */ void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][128], float &totusers, float &totservers); /** Handle remote MOTD */ int HandleMotd(const char** parameters, int pcnt, userrec* user); /** Handle remote ADMIN */ int HandleAdmin(const char** parameters, int pcnt, userrec* user); /** Handle remote STATS */ int HandleStats(const char** parameters, int pcnt, userrec* user); /** Handle MAP command */ void HandleMap(const char** parameters, int pcnt, userrec* user); /** Handle SQUIT */ int HandleSquit(const char** parameters, int pcnt, userrec* user); /** Handle TIME */ int HandleTime(const char** parameters, int pcnt, userrec* user); /** Handle remote WHOIS */ int HandleRemoteWhois(const char** parameters, int pcnt, userrec* user); /** Handle remote MODULES */ int HandleModules(const char** parameters, int pcnt, userrec* user); /** Ping all local servers */ void DoPingChecks(time_t curtime); /** Connect a server locally */ void ConnectServer(Link* x); /** Check if any servers are due to be autoconnected */ void AutoConnectServers(time_t curtime); /** Handle remote VERSON */ int HandleVersion(const char** parameters, int pcnt, userrec* user); /** Handle CONNECT */ int HandleConnect(const char** parameters, int pcnt, userrec* user); /** Send out time sync to all servers */ void BroadcastTimeSync(); /** Returns oper-specific MAP information */ const std::string MapOperInfo(TreeServer* Current); /** Display a time as a human readable string */ std::string TimeToStr(time_t secs); /** ** *** MODULE EVENTS *** **/ virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated, const std::string &original_line); virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, CmdResult result, const std::string &original_line); virtual void OnGetServerDescription(const std::string &servername,std::string &description); virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel); virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic); virtual void OnWallops(userrec* user, const std::string &text); virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list); virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list); virtual void OnBackgroundTimer(time_t curtime); virtual void OnUserJoin(userrec* user, chanrec* channel, bool &silent); virtual void OnChangeHost(userrec* user, const std::string &newhost); virtual void OnChangeName(userrec* user, const std::string &gecos); virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage, bool &silent); virtual void OnUserConnect(userrec* user); virtual void OnUserQuit(userrec* user, const std::string &reason, const std::string &oper_message); virtual void OnUserPostNick(userrec* user, const std::string &oldnick); virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason, bool &silent); virtual void OnRemoteKill(userrec* source, userrec* dest, const std::string &reason, const std::string &operreason); virtual void OnRehash(userrec* user, const std::string ¶meter); virtual void OnOper(userrec* user, const std::string &opertype); void OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason); virtual void OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask); virtual void OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask); virtual void OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask); virtual void OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask); virtual void OnDelGLine(userrec* source, const std::string &hostmask); virtual void OnDelZLine(userrec* source, const std::string &ipmask); virtual void OnDelQLine(userrec* source, const std::string &nickmask); virtual void OnDelELine(userrec* source, const std::string &hostmask); virtual void OnMode(userrec* user, void* dest, int target_type, const std::string &text); virtual int OnStats(char statschar, userrec* user, string_list &results); virtual void OnSetAway(userrec* user); virtual void OnCancelAway(userrec* user); virtual void ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline); virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata); virtual void OnEvent(Event* event); virtual ~ModuleSpanningTree(); virtual Version GetVersion(); void Implements(char* List); Priority Prioritize(); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __ST_MAIN__ +#define __ST_MAIN__ + +#include "inspircd.h" +#include "modules.h" + +/** If you make a change which breaks the protocol, increment this. + * If you completely change the protocol, completely change the number. + * + * IMPORTANT: If you make changes, document your changes here, without fail: + * http://www.inspircd.org/wiki/List_of_protocol_changes_between_versions + * + * Failure to document your protocol changes will result in a painfully + * painful death by pain. You have been warned. + */ +const long ProtocolVersion = 1105; + +/** Forward declarations + */ +class cmd_rconnect; +class cmd_rsquit; +class SpanningTreeUtilities; +class TimeSyncTimer; +class CacheRefreshTimer; +class TreeServer; +class Link; + +/** This is the main class for the spanningtree module + */ +class ModuleSpanningTree : public Module +{ + int line; + int NumServers; + unsigned int max_local; + unsigned int max_global; + cmd_rconnect* command_rconnect; + cmd_rsquit* command_rsquit; + SpanningTreeUtilities* Utils; + + public: + /** Timer for clock syncs + */ + TimeSyncTimer *SyncTimer; + + CacheRefreshTimer *RefreshTimer; + + /** Constructor + */ + ModuleSpanningTree(InspIRCd* Me); + + /** Shows /LINKS + */ + void ShowLinks(TreeServer* Current, userrec* user, int hops); + + /** Counts local servers + */ + int CountLocalServs(); + + /** Counts local and remote servers + */ + int CountServs(); + + /** Handle LINKS command + */ + void HandleLinks(const char** parameters, int pcnt, userrec* user); + + /** Handle LUSERS command + */ + void HandleLusers(const char** parameters, int pcnt, userrec* user); + + /** Show MAP output to a user (recursive) + */ + void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][128], float &totusers, float &totservers); + + /** Handle remote MOTD + */ + int HandleMotd(const char** parameters, int pcnt, userrec* user); + + /** Handle remote ADMIN + */ + int HandleAdmin(const char** parameters, int pcnt, userrec* user); + + /** Handle remote STATS + */ + int HandleStats(const char** parameters, int pcnt, userrec* user); + + /** Handle MAP command + */ + void HandleMap(const char** parameters, int pcnt, userrec* user); + + /** Handle SQUIT + */ + int HandleSquit(const char** parameters, int pcnt, userrec* user); + + /** Handle TIME + */ + int HandleTime(const char** parameters, int pcnt, userrec* user); + + /** Handle remote WHOIS + */ + int HandleRemoteWhois(const char** parameters, int pcnt, userrec* user); + + /** Handle remote MODULES + */ + int HandleModules(const char** parameters, int pcnt, userrec* user); + + /** Ping all local servers + */ + void DoPingChecks(time_t curtime); + + /** Connect a server locally + */ + void ConnectServer(Link* x); + + /** Check if any servers are due to be autoconnected + */ + void AutoConnectServers(time_t curtime); + + /** Handle remote VERSON + */ + int HandleVersion(const char** parameters, int pcnt, userrec* user); + + /** Handle CONNECT + */ + int HandleConnect(const char** parameters, int pcnt, userrec* user); + + /** Send out time sync to all servers + */ + void BroadcastTimeSync(); + + /** Returns oper-specific MAP information + */ + const std::string MapOperInfo(TreeServer* Current); + + /** Display a time as a human readable string + */ + std::string TimeToStr(time_t secs); + + /** + ** *** MODULE EVENTS *** + **/ + + virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated, const std::string &original_line); + virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, CmdResult result, const std::string &original_line); + virtual void OnGetServerDescription(const std::string &servername,std::string &description); + virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel); + virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic); + virtual void OnWallops(userrec* user, const std::string &text); + virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list); + virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list); + virtual void OnBackgroundTimer(time_t curtime); + virtual void OnUserJoin(userrec* user, chanrec* channel, bool &silent); + virtual void OnChangeHost(userrec* user, const std::string &newhost); + virtual void OnChangeName(userrec* user, const std::string &gecos); + virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage, bool &silent); + virtual void OnUserConnect(userrec* user); + virtual void OnUserQuit(userrec* user, const std::string &reason, const std::string &oper_message); + virtual void OnUserPostNick(userrec* user, const std::string &oldnick); + virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason, bool &silent); + virtual void OnRemoteKill(userrec* source, userrec* dest, const std::string &reason, const std::string &operreason); + virtual void OnRehash(userrec* user, const std::string ¶meter); + virtual void OnOper(userrec* user, const std::string &opertype); + void OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason); + virtual void OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask); + virtual void OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask); + virtual void OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask); + virtual void OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask); + virtual void OnDelGLine(userrec* source, const std::string &hostmask); + virtual void OnDelZLine(userrec* source, const std::string &ipmask); + virtual void OnDelQLine(userrec* source, const std::string &nickmask); + virtual void OnDelELine(userrec* source, const std::string &hostmask); + virtual void OnMode(userrec* user, void* dest, int target_type, const std::string &text); + virtual int OnStats(char statschar, userrec* user, string_list &results); + virtual void OnSetAway(userrec* user); + virtual void OnCancelAway(userrec* user); + virtual void ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline); + virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata); + virtual void OnEvent(Event* event); + virtual ~ModuleSpanningTree(); + virtual Version GetVersion(); + void Implements(char* List); + Priority Prioritize(); +}; + +#endif diff --git a/src/modules/m_spanningtree/rconnect.cpp b/src/modules/m_spanningtree/rconnect.cpp index 88b1fde8b..5500ccdc0 100644 --- a/src/modules/m_spanningtree/rconnect.cpp +++ b/src/modules/m_spanningtree/rconnect.cpp @@ -1 +1,67 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/timesynctimer.h" #include "m_spanningtree/resolvers.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" #include "m_spanningtree/rconnect.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h */ cmd_rconnect::cmd_rconnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : command_t(Instance, "RCONNECT", 'o', 2), Creator(Callback), Utils(Util) { this->source = "m_spanningtree.so"; syntax = " "; } CmdResult cmd_rconnect::Handle (const char** parameters, int pcnt, userrec *user) { if (IS_LOCAL(user)) { if (!Utils->FindServerMask(parameters[0])) { user->WriteServ("NOTICE %s :*** RCONNECT: Server \002%s\002 isn't connected to the network!", user->nick, parameters[0]); return CMD_FAILURE; } user->WriteServ("NOTICE %s :*** RCONNECT: Sending remote connect to \002%s\002 to connect server \002%s\002.",user->nick,parameters[0],parameters[1]); } /* Is this aimed at our server? */ if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameters[0])) { /* Yes, initiate the given connect */ 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]; std::string original_command = std::string("CONNECT ") + parameters[1]; Creator->OnPreCommand("CONNECT", para, 1, user, true, original_command); } return CMD_SUCCESS; } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/timesynctimer.h" +#include "m_spanningtree/resolvers.h" +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" +#include "m_spanningtree/rconnect.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h */ + +cmd_rconnect::cmd_rconnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : command_t(Instance, "RCONNECT", 'o', 2), Creator(Callback), Utils(Util) +{ + this->source = "m_spanningtree.so"; + syntax = " "; +} + +CmdResult cmd_rconnect::Handle (const char** parameters, int pcnt, userrec *user) +{ + if (IS_LOCAL(user)) + { + if (!Utils->FindServerMask(parameters[0])) + { + user->WriteServ("NOTICE %s :*** RCONNECT: Server \002%s\002 isn't connected to the network!", user->nick, parameters[0]); + return CMD_FAILURE; + } + user->WriteServ("NOTICE %s :*** RCONNECT: Sending remote connect to \002%s\002 to connect server \002%s\002.",user->nick,parameters[0],parameters[1]); + } + + /* Is this aimed at our server? */ + if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameters[0])) + { + /* Yes, initiate the given connect */ + 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]; + std::string original_command = std::string("CONNECT ") + parameters[1]; + Creator->OnPreCommand("CONNECT", para, 1, user, true, original_command); + } + return CMD_SUCCESS; +} + diff --git a/src/modules/m_spanningtree/rconnect.h b/src/modules/m_spanningtree/rconnect.h index fca96f4a8..77e271949 100644 --- a/src/modules/m_spanningtree/rconnect.h +++ b/src/modules/m_spanningtree/rconnect.h @@ -1 +1,28 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __RCONNECT_H__ #define __RCONNECT_H__ /** Handle /RCONNECT */ class cmd_rconnect : public command_t { Module* Creator; /* Creator */ SpanningTreeUtilities* Utils; /* Utility class */ public: cmd_rconnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util); CmdResult Handle (const char** parameters, int pcnt, userrec *user); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __RCONNECT_H__ +#define __RCONNECT_H__ + +/** Handle /RCONNECT + */ +class cmd_rconnect : public command_t +{ + Module* Creator; /* Creator */ + SpanningTreeUtilities* Utils; /* Utility class */ + public: + cmd_rconnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util); + CmdResult Handle (const char** parameters, int pcnt, userrec *user); +}; + +#endif diff --git a/src/modules/m_spanningtree/resolvers.cpp b/src/modules/m_spanningtree/resolvers.cpp index 80971c699..0d94da99f 100644 --- a/src/modules/m_spanningtree/resolvers.cpp +++ b/src/modules/m_spanningtree/resolvers.cpp @@ -1 +1,88 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/resolvers.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ /** This class is used to resolve server hostnames during /connect and autoconnect. * As of 1.1, the resolver system is seperated out from InspSocket, so we must do this * resolver step first ourselves if we need it. This is totally nonblocking, and will * callback to OnLookupComplete or OnError when completed. Once it has completed we * will have an IP address which we can then use to continue our connection. */ ServernameResolver::ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt) : Resolver(Instance, hostname, qt, cached, me), MyLink(x), Utils(Util), query(qt), host(hostname), mine(me) { /* Nothing in here, folks */ } void ServernameResolver::OnLookupComplete(const std::string &result, unsigned int ttl, bool cached) { /* Initiate the connection, now that we have an IP to use. * Passing a hostname directly to InspSocket causes it to * just bail and set its FD to -1. */ TreeServer* CheckDupe = Utils->FindServer(MyLink.Name.c_str()); if (!CheckDupe) /* Check that nobody tried to connect it successfully while we were resolving */ { if ((!MyLink.Hook.empty()) && (Utils->hooks.find(MyLink.Hook.c_str()) == Utils->hooks.end())) return; TreeSocket* newsocket = new TreeSocket(this->Utils, ServerInstance, result,MyLink.Port,false,MyLink.Timeout ? MyLink.Timeout : 10,MyLink.Name.c_str(), MyLink.Bind, MyLink.Hook.empty() ? NULL : Utils->hooks[MyLink.Hook.c_str()]); if (newsocket->GetFd() > -1) { /* We're all OK */ } else { /* Something barfed, show the opers */ ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",MyLink.Name.c_str(),strerror(errno)); delete newsocket; Utils->DoFailOver(&MyLink); } } } void ServernameResolver::OnError(ResolverError e, const std::string &errormessage) { /* Ooops! */ if (query == DNS_QUERY_AAAA) { bool cached; ServernameResolver* snr = new ServernameResolver(mine, Utils, ServerInstance, host, MyLink, cached, DNS_QUERY_A); ServerInstance->AddResolver(snr, cached); return; } ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: Unable to resolve hostname - %s",MyLink.Name.c_str(),errormessage.c_str()); Utils->DoFailOver(&MyLink); } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/resolvers.h" +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ + +/** This class is used to resolve server hostnames during /connect and autoconnect. + * As of 1.1, the resolver system is seperated out from InspSocket, so we must do this + * resolver step first ourselves if we need it. This is totally nonblocking, and will + * callback to OnLookupComplete or OnError when completed. Once it has completed we + * will have an IP address which we can then use to continue our connection. + */ +ServernameResolver::ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt) : Resolver(Instance, hostname, qt, cached, me), MyLink(x), Utils(Util), query(qt), host(hostname), mine(me) +{ + /* Nothing in here, folks */ +} + +void ServernameResolver::OnLookupComplete(const std::string &result, unsigned int ttl, bool cached) +{ + /* Initiate the connection, now that we have an IP to use. + * Passing a hostname directly to InspSocket causes it to + * just bail and set its FD to -1. + */ + TreeServer* CheckDupe = Utils->FindServer(MyLink.Name.c_str()); + if (!CheckDupe) /* Check that nobody tried to connect it successfully while we were resolving */ + { + + if ((!MyLink.Hook.empty()) && (Utils->hooks.find(MyLink.Hook.c_str()) == Utils->hooks.end())) + return; + + TreeSocket* newsocket = new TreeSocket(this->Utils, ServerInstance, result,MyLink.Port,false,MyLink.Timeout ? MyLink.Timeout : 10,MyLink.Name.c_str(), + MyLink.Bind, MyLink.Hook.empty() ? NULL : Utils->hooks[MyLink.Hook.c_str()]); + if (newsocket->GetFd() > -1) + { + /* We're all OK */ + } + else + { + /* Something barfed, show the opers */ + ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",MyLink.Name.c_str(),strerror(errno)); + delete newsocket; + Utils->DoFailOver(&MyLink); + } + } +} + +void ServernameResolver::OnError(ResolverError e, const std::string &errormessage) +{ + /* Ooops! */ + if (query == DNS_QUERY_AAAA) + { + bool cached; + ServernameResolver* snr = new ServernameResolver(mine, Utils, ServerInstance, host, MyLink, cached, DNS_QUERY_A); + ServerInstance->AddResolver(snr, cached); + return; + } + ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: Unable to resolve hostname - %s",MyLink.Name.c_str(),errormessage.c_str()); + Utils->DoFailOver(&MyLink); +} + diff --git a/src/modules/m_spanningtree/resolvers.h b/src/modules/m_spanningtree/resolvers.h index 0ba9d6bd6..06fd05bad 100644 --- a/src/modules/m_spanningtree/resolvers.h +++ b/src/modules/m_spanningtree/resolvers.h @@ -1 +1,90 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __RESOLVERS__H__ #define __RESOLVERS__H__ #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "inspircd.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/link.h" /** Handle resolving of server IPs for the cache */ class SecurityIPResolver : public Resolver { private: Link MyLink; SpanningTreeUtilities* Utils; Module* mine; std::string host; QueryType query; public: SecurityIPResolver(Module* me, SpanningTreeUtilities* U, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt) : Resolver(Instance, hostname, qt, cached, me), MyLink(x), Utils(U), mine(me), host(hostname), query(qt) { } void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached) { Utils->ValidIPs.push_back(result); } void OnError(ResolverError e, const std::string &errormessage) { if (query == DNS_QUERY_AAAA) { bool cached; SecurityIPResolver* res = new SecurityIPResolver(mine, Utils, ServerInstance, host, MyLink, cached, DNS_QUERY_A); ServerInstance->AddResolver(res, cached); return; } ServerInstance->Log(DEFAULT,"Could not resolve IP associated with Link '%s': %s",MyLink.Name.c_str(),errormessage.c_str()); } }; /** This class is used to resolve server hostnames during /connect and autoconnect. * As of 1.1, the resolver system is seperated out from InspSocket, so we must do this * resolver step first ourselves if we need it. This is totally nonblocking, and will * callback to OnLookupComplete or OnError when completed. Once it has completed we * will have an IP address which we can then use to continue our connection. */ class ServernameResolver : public Resolver { private: /** A copy of the Link tag info for what we're connecting to. * We take a copy, rather than using a pointer, just in case the * admin takes the tag away and rehashes while the domain is resolving. */ Link MyLink; SpanningTreeUtilities* Utils; QueryType query; std::string host; Module* mine; public: ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt); void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached); void OnError(ResolverError e, const std::string &errormessage); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __RESOLVERS__H__ +#define __RESOLVERS__H__ + +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "inspircd.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/utils.h" +#include "m_spanningtree/link.h" + +/** Handle resolving of server IPs for the cache + */ +class SecurityIPResolver : public Resolver +{ + private: + Link MyLink; + SpanningTreeUtilities* Utils; + Module* mine; + std::string host; + QueryType query; + public: + SecurityIPResolver(Module* me, SpanningTreeUtilities* U, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt) + : Resolver(Instance, hostname, qt, cached, me), MyLink(x), Utils(U), mine(me), host(hostname), query(qt) + { + } + + void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached) + { + Utils->ValidIPs.push_back(result); + } + + void OnError(ResolverError e, const std::string &errormessage) + { + if (query == DNS_QUERY_AAAA) + { + bool cached; + SecurityIPResolver* res = new SecurityIPResolver(mine, Utils, ServerInstance, host, MyLink, cached, DNS_QUERY_A); + ServerInstance->AddResolver(res, cached); + return; + } + ServerInstance->Log(DEFAULT,"Could not resolve IP associated with Link '%s': %s",MyLink.Name.c_str(),errormessage.c_str()); + } +}; + +/** This class is used to resolve server hostnames during /connect and autoconnect. + * As of 1.1, the resolver system is seperated out from InspSocket, so we must do this + * resolver step first ourselves if we need it. This is totally nonblocking, and will + * callback to OnLookupComplete or OnError when completed. Once it has completed we + * will have an IP address which we can then use to continue our connection. + */ +class ServernameResolver : public Resolver +{ + private: + /** A copy of the Link tag info for what we're connecting to. + * We take a copy, rather than using a pointer, just in case the + * admin takes the tag away and rehashes while the domain is resolving. + */ + Link MyLink; + SpanningTreeUtilities* Utils; + QueryType query; + std::string host; + Module* mine; + public: + ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt); + void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached); + void OnError(ResolverError e, const std::string &errormessage); +}; + +#endif diff --git a/src/modules/m_spanningtree/rsquit.cpp b/src/modules/m_spanningtree/rsquit.cpp index 7bb6abfc1..5f3d33fc0 100644 --- a/src/modules/m_spanningtree/rsquit.cpp +++ b/src/modules/m_spanningtree/rsquit.cpp @@ -1 +1,123 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/timesynctimer.h" #include "m_spanningtree/resolvers.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" #include "m_spanningtree/rsquit.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rsquit.h */ cmd_rsquit::cmd_rsquit (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : command_t(Instance, "RSQUIT", 'o', 1), Creator(Callback), Utils(Util) { this->source = "m_spanningtree.so"; syntax = " [target-server-mask]"; } CmdResult cmd_rsquit::Handle (const char** parameters, int pcnt, userrec *user) { if (IS_LOCAL(user)) { if (!Utils->FindServerMask(parameters[0])) { user->WriteServ("NOTICE %s :*** RSQUIT: Server \002%s\002 isn't connected to the network!", user->nick, parameters[0]); return CMD_FAILURE; } if (pcnt > 1) user->WriteServ("NOTICE %s :*** RSQUIT: Sending remote squit to \002%s\002 to squit server \002%s\002.",user->nick,parameters[0],parameters[1]); else user->WriteServ("NOTICE %s :*** RSQUIT: Sending remote squit for server \002%s\002.",user->nick,parameters[0]); } TreeServer* s = (pcnt > 1) ? Utils->FindServerMask(parameters[1]) : Utils->FindServerMask(parameters[0]); if (pcnt > 1) { if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameters[0])) { if (s) { if (s == Utils->TreeRoot) { NoticeUser(user, "*** RSQUIT: Foolish mortal, you cannot make a server SQUIT itself! ("+ConvToStr(parameters[1])+" matches local server name)"); return CMD_FAILURE; } TreeSocket* sock = s->GetSocket(); if (!sock) { NoticeUser(user, "*** RSQUIT: Server \002"+ConvToStr(parameters[1])+"\002 isn't connected to \002"+ConvToStr(parameters[0])+"\002."); return CMD_FAILURE; } ServerInstance->SNO->WriteToSnoMask('l',"Remote SQUIT from %s matching \002%s\002, squitting server \002%s\002",user->nick,parameters[0],parameters[1]); const char* para[1]; para[0] = parameters[1]; std::string original_command = std::string("SQUIT ") + parameters[1]; Creator->OnPreCommand("SQUIT", para, 1, user, true, original_command); return CMD_LOCALONLY; } } } else { if (s) { if (s == Utils->TreeRoot) { NoticeUser(user, "*** RSQUIT: Foolish mortal, you cannot make a server SQUIT itself! ("+ConvToStr(parameters[0])+" matches local server name)"); return CMD_FAILURE; } TreeSocket* sock = s->GetSocket(); if (sock) { ServerInstance->SNO->WriteToSnoMask('l',"RSQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick); sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost()); ServerInstance->SE->DelFd(sock); sock->Close(); return CMD_LOCALONLY; } } } return CMD_SUCCESS; } void cmd_rsquit::NoticeUser(userrec* user, const std::string &msg) { if (IS_LOCAL(user)) { user->WriteServ("NOTICE %s :%s",user->nick,msg.c_str()); } else { std::deque params; params.push_back(user->nick); params.push_back("NOTICE "+ConvToStr(user->nick)+" :"+msg); Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", params, user->server); } } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/timesynctimer.h" +#include "m_spanningtree/resolvers.h" +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" +#include "m_spanningtree/rsquit.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rsquit.h */ + +cmd_rsquit::cmd_rsquit (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : command_t(Instance, "RSQUIT", 'o', 1), Creator(Callback), Utils(Util) +{ + this->source = "m_spanningtree.so"; + syntax = " [target-server-mask]"; +} + +CmdResult cmd_rsquit::Handle (const char** parameters, int pcnt, userrec *user) +{ + if (IS_LOCAL(user)) + { + if (!Utils->FindServerMask(parameters[0])) + { + user->WriteServ("NOTICE %s :*** RSQUIT: Server \002%s\002 isn't connected to the network!", user->nick, parameters[0]); + return CMD_FAILURE; + } + if (pcnt > 1) + user->WriteServ("NOTICE %s :*** RSQUIT: Sending remote squit to \002%s\002 to squit server \002%s\002.",user->nick,parameters[0],parameters[1]); + else + user->WriteServ("NOTICE %s :*** RSQUIT: Sending remote squit for server \002%s\002.",user->nick,parameters[0]); + } + + TreeServer* s = (pcnt > 1) ? Utils->FindServerMask(parameters[1]) : Utils->FindServerMask(parameters[0]); + + if (pcnt > 1) + { + if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameters[0])) + { + if (s) + { + if (s == Utils->TreeRoot) + { + NoticeUser(user, "*** RSQUIT: Foolish mortal, you cannot make a server SQUIT itself! ("+ConvToStr(parameters[1])+" matches local server name)"); + return CMD_FAILURE; + } + TreeSocket* sock = s->GetSocket(); + if (!sock) + { + NoticeUser(user, "*** RSQUIT: Server \002"+ConvToStr(parameters[1])+"\002 isn't connected to \002"+ConvToStr(parameters[0])+"\002."); + return CMD_FAILURE; + } + ServerInstance->SNO->WriteToSnoMask('l',"Remote SQUIT from %s matching \002%s\002, squitting server \002%s\002",user->nick,parameters[0],parameters[1]); + const char* para[1]; + para[0] = parameters[1]; + std::string original_command = std::string("SQUIT ") + parameters[1]; + Creator->OnPreCommand("SQUIT", para, 1, user, true, original_command); + return CMD_LOCALONLY; + } + } + } + else + { + if (s) + { + if (s == Utils->TreeRoot) + { + NoticeUser(user, "*** RSQUIT: Foolish mortal, you cannot make a server SQUIT itself! ("+ConvToStr(parameters[0])+" matches local server name)"); + return CMD_FAILURE; + } + TreeSocket* sock = s->GetSocket(); + if (sock) + { + ServerInstance->SNO->WriteToSnoMask('l',"RSQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick); + sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost()); + ServerInstance->SE->DelFd(sock); + sock->Close(); + return CMD_LOCALONLY; + } + } + } + + return CMD_SUCCESS; +} + +void cmd_rsquit::NoticeUser(userrec* user, const std::string &msg) +{ + if (IS_LOCAL(user)) + { + user->WriteServ("NOTICE %s :%s",user->nick,msg.c_str()); + } + else + { + std::deque params; + params.push_back(user->nick); + params.push_back("NOTICE "+ConvToStr(user->nick)+" :"+msg); + Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", params, user->server); + } +} diff --git a/src/modules/m_spanningtree/rsquit.h b/src/modules/m_spanningtree/rsquit.h index ed9eb83d4..81e9bc2b7 100644 --- a/src/modules/m_spanningtree/rsquit.h +++ b/src/modules/m_spanningtree/rsquit.h @@ -1 +1,29 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __RSQUIT_H__ #define __RSQUIT_H__ /** Handle /RCONNECT */ class cmd_rsquit : public command_t { Module* Creator; /* Creator */ SpanningTreeUtilities* Utils; /* Utility class */ public: cmd_rsquit (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util); CmdResult Handle (const char** parameters, int pcnt, userrec *user); void NoticeUser(userrec* user, const std::string &msg); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __RSQUIT_H__ +#define __RSQUIT_H__ + +/** Handle /RCONNECT + */ +class cmd_rsquit : public command_t +{ + Module* Creator; /* Creator */ + SpanningTreeUtilities* Utils; /* Utility class */ + public: + cmd_rsquit (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util); + CmdResult Handle (const char** parameters, int pcnt, userrec *user); + void NoticeUser(userrec* user, const std::string &msg); +}; + +#endif diff --git a/src/modules/m_spanningtree/timesynctimer.cpp b/src/modules/m_spanningtree/timesynctimer.cpp index 8ecb84a4b..af615e91e 100644 --- a/src/modules/m_spanningtree/timesynctimer.cpp +++ b/src/modules/m_spanningtree/timesynctimer.cpp @@ -1 +1,52 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/timesynctimer.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ TimeSyncTimer::TimeSyncTimer(InspIRCd *Inst, ModuleSpanningTree *Mod) : InspTimer(600, Inst->Time(), true), Instance(Inst), Module(Mod) { } void TimeSyncTimer::Tick(time_t TIME) { Module->BroadcastTimeSync(); } CacheRefreshTimer::CacheRefreshTimer(InspIRCd *Inst, SpanningTreeUtilities *Util) : InspTimer(3600, Inst->Time(), true), Instance(Inst), Utils(Util) { } void CacheRefreshTimer::Tick(time_t TIME) { Utils->RefreshIPCache(); } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/timesynctimer.h" +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ + +TimeSyncTimer::TimeSyncTimer(InspIRCd *Inst, ModuleSpanningTree *Mod) : InspTimer(600, Inst->Time(), true), Instance(Inst), Module(Mod) +{ +} + +void TimeSyncTimer::Tick(time_t TIME) +{ + Module->BroadcastTimeSync(); +} + +CacheRefreshTimer::CacheRefreshTimer(InspIRCd *Inst, SpanningTreeUtilities *Util) : InspTimer(3600, Inst->Time(), true), Instance(Inst), Utils(Util) +{ +} + +void CacheRefreshTimer::Tick(time_t TIME) +{ + Utils->RefreshIPCache(); +} + diff --git a/src/modules/m_spanningtree/timesynctimer.h b/src/modules/m_spanningtree/timesynctimer.h index dd23ee171..434ee253c 100644 --- a/src/modules/m_spanningtree/timesynctimer.h +++ b/src/modules/m_spanningtree/timesynctimer.h @@ -1 +1,47 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __TIMESYNC_H__ #define __TIMESYNC_H__ #include "timer.h" class ModuleSpanningTree; class SpanningTreeUtilities; class InspIRCd; /** Create a timer which recurs every second, we inherit from InspTimer. * InspTimer is only one-shot however, so at the end of each Tick() we simply * insert another of ourselves into the pending queue :) */ class TimeSyncTimer : public InspTimer { private: InspIRCd *Instance; ModuleSpanningTree *Module; public: TimeSyncTimer(InspIRCd *Instance, ModuleSpanningTree *Mod); virtual void Tick(time_t TIME); }; class CacheRefreshTimer : public InspTimer { private: InspIRCd *Instance; SpanningTreeUtilities *Utils; public: CacheRefreshTimer(InspIRCd *Instance, SpanningTreeUtilities* Util); virtual void Tick(time_t TIME); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __TIMESYNC_H__ +#define __TIMESYNC_H__ + +#include "timer.h" + +class ModuleSpanningTree; +class SpanningTreeUtilities; +class InspIRCd; + +/** Create a timer which recurs every second, we inherit from InspTimer. + * InspTimer is only one-shot however, so at the end of each Tick() we simply + * insert another of ourselves into the pending queue :) + */ +class TimeSyncTimer : public InspTimer +{ + private: + InspIRCd *Instance; + ModuleSpanningTree *Module; + public: + TimeSyncTimer(InspIRCd *Instance, ModuleSpanningTree *Mod); + virtual void Tick(time_t TIME); +}; + +class CacheRefreshTimer : public InspTimer +{ + private: + InspIRCd *Instance; + SpanningTreeUtilities *Utils; + public: + CacheRefreshTimer(InspIRCd *Instance, SpanningTreeUtilities* Util); + virtual void Tick(time_t TIME); +}; + +#endif diff --git a/src/modules/m_spanningtree/treeserver.cpp b/src/modules/m_spanningtree/treeserver.cpp index 670f7e420..b5cac1802 100644 --- a/src/modules/m_spanningtree/treeserver.cpp +++ b/src/modules/m_spanningtree/treeserver.cpp @@ -1 +1,325 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" /* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h */ TreeServer::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance) : ServerInstance(Instance), Utils(Util) { Parent = NULL; ServerName.clear(); ServerDesc.clear(); VersionString.clear(); UserCount = OperCount = 0; rtt = LastPing = 0; Hidden = false; VersionString = ServerInstance->GetVersionString(); } /** 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::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc) : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc), Utils(Util) { Parent = NULL; VersionString.clear(); UserCount = ServerInstance->UserCount(); OperCount = ServerInstance->OperCount(); VersionString = ServerInstance->GetVersionString(); Route = NULL; Socket = NULL; /* Fix by brain */ rtt = LastPing = 0; Hidden = false; AddHashEntry(); } /** 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::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock, bool Hide) : ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock), Utils(Util), Hidden(Hide) { VersionString.clear(); UserCount = OperCount = 0; this->SetNextPingTime(time(NULL) + 60); this->SetPingFlag(); rtt = LastPing = 0; /* find the 'route' for this server (e.g. the one directly connected * to the local server, which we can use to reach it) * * In the following example, consider we have just added a TreeServer * class for server G on our network, of which we are server A. * To route traffic to G (marked with a *) we must send the data to * B (marked with a +) so this algorithm initializes the 'Route' * value to point at whichever server traffic must be routed through * to get here. If we were to try this algorithm with server B, * the Route pointer would point at its own object ('this'). * * A * / \ * + B C * / \ \ * D E F * / \ * * G H * * We only run this algorithm when a server is created, as * the routes remain constant while ever the server exists, and * do not need to be re-calculated. */ Route = Above; if (Route == Utils->TreeRoot) { Route = this; } else { while (this->Route->GetParent() != Utils->TreeRoot) { this->Route = Route->GetParent(); } } /* Because recursive code is slow and takes a lot of resources, * we store two representations of the server tree. The first * is a recursive structure where each server references its * children and its parent, which is used for netbursts and * netsplits to dump the whole dataset to the other server, * and the second is used for very fast lookups when routing * messages and is instead a hash_map, where each item can * be referenced by its server name. The AddHashEntry() * call below automatically inserts each TreeServer class * into the hash_map as it is created. There is a similar * maintainance call in the destructor to tidy up deleted * servers. */ this->AddHashEntry(); } int TreeServer::QuitUsers(const std::string &reason) { const char* reason_s = reason.c_str(); std::vector time_to_die; for (user_hash::iterator n = ServerInstance->clientlist->begin(); n != ServerInstance->clientlist->end(); n++) { if (!strcmp(n->second->server, this->ServerName.c_str())) { time_to_die.push_back(n->second); } } for (std::vector::iterator n = time_to_die.begin(); n != time_to_die.end(); n++) { userrec* a = (userrec*)*n; if (!IS_LOCAL(a)) { if (ServerInstance->Config->HideSplits) userrec::QuitUser(ServerInstance, a, "*.net *.split", reason_s); else userrec::QuitUser(ServerInstance, a, reason_s); if (this->Utils->quiet_bursts) ServerInstance->GlobalCulls.MakeSilent(a); } } return time_to_die.size(); } /** This method is used to add the structure to the * hash_map for linear searches. It is only called * by the constructors. */ void TreeServer::AddHashEntry() { 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 * from the hash_map which is used for linear searches. * It is only called by the default destructor. */ void TreeServer::DelHashEntry() { 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- * explanitory. */ TreeServer* TreeServer::GetRoute() { return Route; } std::string TreeServer::GetName() { return ServerName.c_str(); } std::string TreeServer::GetDesc() { return ServerDesc; } std::string TreeServer::GetVersion() { return VersionString; } void TreeServer::SetNextPingTime(time_t t) { this->NextPing = t; LastPingWasGood = false; } time_t TreeServer::NextPingTime() { return NextPing; } bool TreeServer::AnsweredLastPing() { return LastPingWasGood; } void TreeServer::SetPingFlag() { LastPingWasGood = true; } int TreeServer::GetUserCount() { return UserCount; } void TreeServer::AddUserCount() { UserCount++; } void TreeServer::DelUserCount() { UserCount--; } int TreeServer::GetOperCount() { return OperCount; } TreeSocket* TreeServer::GetSocket() { return Socket; } TreeServer* TreeServer::GetParent() { return Parent; } void TreeServer::SetVersion(const std::string &Version) { VersionString = Version; } unsigned int TreeServer::ChildCount() { return Children.size(); } TreeServer* TreeServer::GetChild(unsigned int n) { if (n < Children.size()) { /* Make sure they cant request * an out-of-range object. After * all we know what these programmer * types are like *grin*. */ return Children[n]; } else { return NULL; } } void TreeServer::AddChild(TreeServer* Child) { Children.push_back(Child); } bool TreeServer::DelChild(TreeServer* Child) { for (std::vector::iterator a = Children.begin(); a < Children.end(); a++) { if (*a == Child) { Children.erase(a); return true; } } return false; } /** 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. */ bool TreeServer::Tidy() { bool stillchildren = true; while (stillchildren) { stillchildren = false; for (std::vector::iterator a = Children.begin(); a < Children.end(); a++) { TreeServer* s = (TreeServer*)*a; s->Tidy(); Children.erase(a); DELETE(s); stillchildren = true; break; } } return true; } TreeServer::~TreeServer() { /* We'd better tidy up after ourselves, eh? */ this->DelHashEntry(); } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" + +/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h */ + +TreeServer::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance) : ServerInstance(Instance), Utils(Util) +{ + Parent = NULL; + ServerName.clear(); + ServerDesc.clear(); + VersionString.clear(); + UserCount = OperCount = 0; + rtt = LastPing = 0; + Hidden = false; + VersionString = ServerInstance->GetVersionString(); +} + +/** 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::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc) : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc), Utils(Util) +{ + Parent = NULL; + VersionString.clear(); + UserCount = ServerInstance->UserCount(); + OperCount = ServerInstance->OperCount(); + VersionString = ServerInstance->GetVersionString(); + Route = NULL; + Socket = NULL; /* Fix by brain */ + rtt = LastPing = 0; + Hidden = false; + AddHashEntry(); +} + +/** 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::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock, bool Hide) + : ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock), Utils(Util), Hidden(Hide) +{ + VersionString.clear(); + UserCount = OperCount = 0; + this->SetNextPingTime(time(NULL) + 60); + this->SetPingFlag(); + rtt = LastPing = 0; + /* find the 'route' for this server (e.g. the one directly connected + * to the local server, which we can use to reach it) + * + * In the following example, consider we have just added a TreeServer + * class for server G on our network, of which we are server A. + * To route traffic to G (marked with a *) we must send the data to + * B (marked with a +) so this algorithm initializes the 'Route' + * value to point at whichever server traffic must be routed through + * to get here. If we were to try this algorithm with server B, + * the Route pointer would point at its own object ('this'). + * + * A + * / \ + * + B C + * / \ \ + * D E F + * / \ + * * G H + * + * We only run this algorithm when a server is created, as + * the routes remain constant while ever the server exists, and + * do not need to be re-calculated. + */ + + Route = Above; + if (Route == Utils->TreeRoot) + { + Route = this; + } + else + { + while (this->Route->GetParent() != Utils->TreeRoot) + { + this->Route = Route->GetParent(); + } + } + + /* Because recursive code is slow and takes a lot of resources, + * we store two representations of the server tree. The first + * is a recursive structure where each server references its + * children and its parent, which is used for netbursts and + * netsplits to dump the whole dataset to the other server, + * and the second is used for very fast lookups when routing + * messages and is instead a hash_map, where each item can + * be referenced by its server name. The AddHashEntry() + * call below automatically inserts each TreeServer class + * into the hash_map as it is created. There is a similar + * maintainance call in the destructor to tidy up deleted + * servers. + */ + + this->AddHashEntry(); +} + +int TreeServer::QuitUsers(const std::string &reason) +{ + const char* reason_s = reason.c_str(); + std::vector time_to_die; + for (user_hash::iterator n = ServerInstance->clientlist->begin(); n != ServerInstance->clientlist->end(); n++) + { + if (!strcmp(n->second->server, this->ServerName.c_str())) + { + time_to_die.push_back(n->second); + } + } + for (std::vector::iterator n = time_to_die.begin(); n != time_to_die.end(); n++) + { + userrec* a = (userrec*)*n; + if (!IS_LOCAL(a)) + { + if (ServerInstance->Config->HideSplits) + userrec::QuitUser(ServerInstance, a, "*.net *.split", reason_s); + else + userrec::QuitUser(ServerInstance, a, reason_s); + + if (this->Utils->quiet_bursts) + ServerInstance->GlobalCulls.MakeSilent(a); + } + } + return time_to_die.size(); +} + +/** This method is used to add the structure to the + * hash_map for linear searches. It is only called + * by the constructors. + */ +void TreeServer::AddHashEntry() +{ + 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 + * from the hash_map which is used for linear searches. + * It is only called by the default destructor. + */ +void TreeServer::DelHashEntry() +{ + 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- + * explanitory. + */ +TreeServer* TreeServer::GetRoute() +{ + return Route; +} + +std::string TreeServer::GetName() +{ + return ServerName.c_str(); +} + +std::string TreeServer::GetDesc() +{ + return ServerDesc; +} + +std::string TreeServer::GetVersion() +{ + return VersionString; +} + +void TreeServer::SetNextPingTime(time_t t) +{ + this->NextPing = t; + LastPingWasGood = false; +} + +time_t TreeServer::NextPingTime() +{ + return NextPing; +} + +bool TreeServer::AnsweredLastPing() +{ + return LastPingWasGood; +} + +void TreeServer::SetPingFlag() +{ + LastPingWasGood = true; +} + +int TreeServer::GetUserCount() +{ + return UserCount; +} + +void TreeServer::AddUserCount() +{ + UserCount++; +} + +void TreeServer::DelUserCount() +{ + UserCount--; +} + +int TreeServer::GetOperCount() +{ + return OperCount; +} + +TreeSocket* TreeServer::GetSocket() +{ + return Socket; +} + +TreeServer* TreeServer::GetParent() +{ + return Parent; +} + +void TreeServer::SetVersion(const std::string &Version) +{ + VersionString = Version; +} + +unsigned int TreeServer::ChildCount() +{ + return Children.size(); +} + +TreeServer* TreeServer::GetChild(unsigned int n) +{ + if (n < Children.size()) + { + /* Make sure they cant request + * an out-of-range object. After + * all we know what these programmer + * types are like *grin*. + */ + return Children[n]; + } + else + { + return NULL; + } +} + +void TreeServer::AddChild(TreeServer* Child) +{ + Children.push_back(Child); +} + +bool TreeServer::DelChild(TreeServer* Child) +{ + for (std::vector::iterator a = Children.begin(); a < Children.end(); a++) + { + if (*a == Child) + { + Children.erase(a); + return true; + } + } + return false; +} + +/** 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. + */ +bool TreeServer::Tidy() +{ + bool stillchildren = true; + while (stillchildren) + { + stillchildren = false; + for (std::vector::iterator a = Children.begin(); a < Children.end(); a++) + { + TreeServer* s = (TreeServer*)*a; + s->Tidy(); + Children.erase(a); + DELETE(s); + stillchildren = true; + break; + } + } + return true; +} + +TreeServer::~TreeServer() +{ + /* We'd better tidy up after ourselves, eh? */ + this->DelHashEntry(); +} + + diff --git a/src/modules/m_spanningtree/treeserver.h b/src/modules/m_spanningtree/treeserver.h index e942c1acc..514d6bc07 100644 --- a/src/modules/m_spanningtree/treeserver.h +++ b/src/modules/m_spanningtree/treeserver.h @@ -1 +1,186 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __TREESERVER_H__ #define __TREESERVER_H__ /** 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. * Each server also maintains a pointer to its parent * (NULL if this server is ours, at the top of the tree) * and a pointer to its "Route" (see the comments in the * constructors below), and also a dynamic list of pointers * to its children which can be iterated recursively * if required. Creating or deleting objects of type i* TreeServer automatically maintains the hash_map of * TreeServer items, deleting and inserting them as they * are created and destroyed. */ class TreeServer : public classbase { InspIRCd* ServerInstance; /* Creator */ TreeServer* Parent; /* Parent entry */ TreeServer* Route; /* Route entry */ std::vector Children; /* List of child objects */ irc::string ServerName; /* Server's name */ std::string ServerDesc; /* Server's description */ std::string VersionString; /* Version string or empty string */ int UserCount; /* Not used in this version */ int OperCount; /* Not used in this version */ 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: bool Warned; /* True if we've warned opers about high latency on this server */ /** 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(SpanningTreeUtilities* Util, InspIRCd* Instance); /** 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(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc); /** 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(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock, bool Hide); int QuitUsers(const std::string &reason); /** This method is used to add the structure to the * hash_map for linear searches. It is only called * by the constructors. */ void AddHashEntry(); /** 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(); /** Get route. * The 'route' is defined as the locally- * connected server which can be used to reach this server. */ TreeServer* GetRoute(); /** Get server name */ std::string GetName(); /** Get server description (GECOS) */ std::string GetDesc(); /** Get server version string */ std::string GetVersion(); /** Set time we are next due to ping this server */ void SetNextPingTime(time_t t); /** Get the time we are next due to ping this server */ time_t NextPingTime(); /** Time of last ping used to calculate this->rtt below */ time_t LastPing; /** Round trip time of last ping */ time_t rtt; /** True if this server is hidden */ bool Hidden; /** True if the server answered their last ping */ bool AnsweredLastPing(); /** Set the server as responding to its last ping */ void SetPingFlag(); /** Get the number of users on this server for MAP */ int GetUserCount(); /** Increment the user counter */ void AddUserCount(); /** Decrement the user counter */ void DelUserCount(); /** Get the oper count for this server */ int GetOperCount(); /** Get the TreeSocket pointer for local servers. * For remote servers, this returns NULL. */ TreeSocket* GetSocket(); /** Get the parent server. * For the root node, this returns NULL. */ TreeServer* GetParent(); /** Set the server version string */ void SetVersion(const std::string &Version); /** Return number of child servers */ unsigned int ChildCount(); /** Return a child server indexed 0..n */ TreeServer* GetChild(unsigned int n); /** Add a child server */ void AddChild(TreeServer* Child); /** Delete a child server, return false if it didn't exist. */ bool DelChild(TreeServer* Child); /** 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. */ bool Tidy(); /** Destructor */ ~TreeServer(); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __TREESERVER_H__ +#define __TREESERVER_H__ + +/** 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. + * Each server also maintains a pointer to its parent + * (NULL if this server is ours, at the top of the tree) + * and a pointer to its "Route" (see the comments in the + * constructors below), and also a dynamic list of pointers + * to its children which can be iterated recursively + * if required. Creating or deleting objects of type + i* TreeServer automatically maintains the hash_map of + * TreeServer items, deleting and inserting them as they + * are created and destroyed. + */ +class TreeServer : public classbase +{ + InspIRCd* ServerInstance; /* Creator */ + TreeServer* Parent; /* Parent entry */ + TreeServer* Route; /* Route entry */ + std::vector Children; /* List of child objects */ + irc::string ServerName; /* Server's name */ + std::string ServerDesc; /* Server's description */ + std::string VersionString; /* Version string or empty string */ + int UserCount; /* Not used in this version */ + int OperCount; /* Not used in this version */ + 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: + + bool Warned; /* True if we've warned opers about high latency on this server */ + + /** 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(SpanningTreeUtilities* Util, InspIRCd* Instance); + + /** 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(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc); + + /** 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(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock, bool Hide); + + int QuitUsers(const std::string &reason); + + /** This method is used to add the structure to the + * hash_map for linear searches. It is only called + * by the constructors. + */ + void AddHashEntry(); + + /** 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(); + + /** Get route. + * The 'route' is defined as the locally- + * connected server which can be used to reach this server. + */ + TreeServer* GetRoute(); + + /** Get server name + */ + std::string GetName(); + + /** Get server description (GECOS) + */ + std::string GetDesc(); + + /** Get server version string + */ + std::string GetVersion(); + + /** Set time we are next due to ping this server + */ + void SetNextPingTime(time_t t); + + /** Get the time we are next due to ping this server + */ + time_t NextPingTime(); + + /** Time of last ping used to calculate this->rtt below + */ + time_t LastPing; + + /** Round trip time of last ping + */ + time_t rtt; + + /** True if this server is hidden + */ + bool Hidden; + + /** True if the server answered their last ping + */ + bool AnsweredLastPing(); + + /** Set the server as responding to its last ping + */ + void SetPingFlag(); + + /** Get the number of users on this server for MAP + */ + int GetUserCount(); + + /** Increment the user counter + */ + void AddUserCount(); + + /** Decrement the user counter + */ + void DelUserCount(); + + /** Get the oper count for this server + */ + int GetOperCount(); + + /** Get the TreeSocket pointer for local servers. + * For remote servers, this returns NULL. + */ + TreeSocket* GetSocket(); + + /** Get the parent server. + * For the root node, this returns NULL. + */ + TreeServer* GetParent(); + + /** Set the server version string + */ + void SetVersion(const std::string &Version); + + /** Return number of child servers + */ + unsigned int ChildCount(); + + /** Return a child server indexed 0..n + */ + TreeServer* GetChild(unsigned int n); + + /** Add a child server + */ + void AddChild(TreeServer* Child); + + /** Delete a child server, return false if it didn't exist. + */ + bool DelChild(TreeServer* Child); + + /** 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. + */ + bool Tidy(); + + /** Destructor + */ + ~TreeServer(); + +}; + +#endif diff --git a/src/modules/m_spanningtree/treesocket.h b/src/modules/m_spanningtree/treesocket.h index bd99c1480..fae22638d 100644 --- a/src/modules/m_spanningtree/treesocket.h +++ b/src/modules/m_spanningtree/treesocket.h @@ -1 +1,413 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __TREESOCKET_H__ #define __TREESOCKET_H__ #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "inspircd.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_spanningtree/utils.h" /* * The server list in InspIRCd is maintained as two structures * which hold the data in different ways. Most of the time, we * want to very quicky obtain three pieces of information: * * (1) The information on a server * (2) The information on the server we must send data through * to actually REACH the server we're after * (3) Potentially, the child/parent objects of this server * * The InspIRCd spanning protocol provides easy access to these * by storing the data firstly in a recursive structure, where * each item references its parent item, and a dynamic list * of child items, and another structure which stores the items * hashed, linearly. This means that if we want to find a server * by name quickly, we can look it up in the hash, avoiding * 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. * 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. * The CONNECTING state indicates an outbound socket which is * waiting to be writeable. * The WAIT_AUTH_1 state indicates the socket is outbound and * has successfully connected, but has not yet sent and received * SERVER strings. * The WAIT_AUTH_2 state indicates that the socket is inbound * (allocated by a LISTENER) but has not yet sent and received * SERVER strings. * The CONNECTED state represents a fully authorized, fully * connected server. */ enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED }; /** 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 * for them, just like activex objects on speed. (yes really, that * is a technical term!) Each of these which relates to a locally * connected server is assocated with it, by hooking it onto a * TreeSocket class using its constructor. In this way, we can * maintain a list of servers, some of which are directly connected, * some of which are not. */ class TreeSocket : public InspSocket { SpanningTreeUtilities* Utils; /* Utility class */ std::string myhost; /* Canonical hostname */ std::string in_buffer; /* Input buffer */ ServerState LinkState; /* Link state */ std::string InboundServerName; /* Server name sent to us by other side */ std::string InboundDescription; /* Server description (GECOS) sent to us by the other side */ int num_lost_users; /* Users lost in split */ int num_lost_servers; /* Servers lost in split */ time_t NextPing; /* Time when we are due to ping this server */ bool LastPingWasGood; /* Responded to last ping we sent? */ bool bursting; /* True if not finished bursting yet */ unsigned int keylength; /* Is this still used? */ std::string ModuleList; /* Module list of other server from CAPAB */ std::map CapKeys; /* CAPAB keys from other server */ Module* Hook; /* I/O hooking module that we're attached to for this socket */ std::string ourchallenge; /* Challenge sent for challenge/response */ std::string theirchallenge; /* Challenge recv for challenge/response */ std::string OutboundPass; /* Outbound password */ bool sentcapab; /* Have sent CAPAB already */ public: /** 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(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, Module* HookMod = NULL); /** 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(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Module* HookMod = NULL); /** 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(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip, Module* HookMod = NULL); /** Get link state */ ServerState GetLinkState(); /** Get challenge set in our CAPAB for challenge/response */ const std::string& GetOurChallenge(); /** Get challenge set in our CAPAB for challenge/response */ void SetOurChallenge(const std::string &c); /** Get challenge set in their CAPAB for challenge/response */ const std::string& GetTheirChallenge(); /** Get challenge set in their CAPAB for challenge/response */ void SetTheirChallenge(const std::string &c); /** Compare two passwords based on authentication scheme */ bool ComparePass(const std::string &ours, const std::string &theirs); /** Return the module which we are hooking to for I/O encapsulation */ Module* GetHook(); /** Destructor */ ~TreeSocket(); /** Generate random string used for challenge-response auth */ std::string RandString(unsigned int length); /** Construct a password, optionally hashed with the other side's * challenge string */ std::string MakePass(const std::string &password, const std::string &challenge); /** 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 * will then send back its own server string. */ virtual bool OnConnected(); /** Handle socket error event */ virtual void OnError(InspSocketError e); /** Sends an error to the remote server, and displays it locally to show * that it was sent. */ void SendError(const std::string &errormessage); /** Handle socket disconnect event */ virtual int OnDisconnect(); /** 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 * end, our connection may be terminated. The hopcounts given * by this function are relative, this doesn't matter so long as * they are all >1, as all the remote servers re-calculate them * to be relative too, with themselves as hop 0. */ void SendServers(TreeServer* Current, TreeServer* s, int hops); /** Returns my capabilities as a string */ std::string MyCapabilities(); /** Send my capabilities to the remote side */ void SendCapabilities(); /* Check a comma seperated list for an item */ bool HasItem(const std::string &list, const std::string &item); /* Isolate and return the elements that are different between two comma seperated lists */ std::string ListDifference(const std::string &one, const std::string &two); bool Capab(const std::deque ¶ms); /** 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 * too many times a month ;-) */ void SquitServer(std::string &from, TreeServer* Current); /** 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, const std::string &reason); /** FMODE command - server mode with timestamp checks */ bool ForceMode(const std::string &source, std::deque ¶ms); /** FTOPIC command */ bool ForceTopic(const std::string &source, std::deque ¶ms); /** FJOIN, similar to TS6 SJOIN, but not quite. */ bool ForceJoin(const std::string &source, std::deque ¶ms); /** NICK command */ bool IntroduceClient(const std::string &source, std::deque ¶ms); /** 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. */ void SendFJoins(TreeServer* Current, chanrec* c); /** Send G, Q, Z and E lines */ void SendXLines(TreeServer* Current); /** Send channel modes and topics */ void SendChannelModes(TreeServer* Current); /** send all users and their oper state/modes */ void SendUsers(TreeServer* Current); /** 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. */ void DoBurst(TreeServer* s); /** 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. * * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES * THE SOCKET OBJECT FOR US. */ virtual bool OnDataReady(); /** Send one or more complete lines down the socket */ int WriteLine(std::string line); /** Handle ERROR command */ bool Error(std::deque ¶ms); /** remote MOTD. leet, huh? */ bool Motd(const std::string &prefix, std::deque ¶ms); /** remote ADMIN. leet, huh? */ bool Admin(const std::string &prefix, std::deque ¶ms); /** Remote MODULES */ bool Modules(const std::string &prefix, std::deque ¶ms); bool Stats(const std::string &prefix, std::deque ¶ms); /** Because the core won't let users or even SERVERS set +o, * we use the OPERTYPE command to do this. */ bool OperType(const std::string &prefix, std::deque ¶ms); /** Because Andy insists that services-compatible servers must * implement SVSNICK and SVSJOIN, that's exactly what we do :p */ bool ForceNick(const std::string &prefix, std::deque ¶ms); bool OperQuit(const std::string &prefix, std::deque ¶ms); /** SVSJOIN */ bool ServiceJoin(const std::string &prefix, std::deque ¶ms); /** REHASH */ bool RemoteRehash(const std::string &prefix, std::deque ¶ms); /** KILL */ bool RemoteKill(const std::string &prefix, std::deque ¶ms); /** PONG */ bool LocalPong(const std::string &prefix, std::deque ¶ms); /** METADATA */ bool MetaData(const std::string &prefix, std::deque ¶ms); /** VERSION */ bool ServerVersion(const std::string &prefix, std::deque ¶ms); /** CHGHOST */ bool ChangeHost(const std::string &prefix, std::deque ¶ms); /** ADDLINE */ bool AddLine(const std::string &prefix, std::deque ¶ms); /** CHGNAME */ bool ChangeName(const std::string &prefix, std::deque ¶ms); /** WHOIS */ bool Whois(const std::string &prefix, std::deque ¶ms); /** PUSH */ bool Push(const std::string &prefix, std::deque ¶ms); /** SETTIME */ bool HandleSetTime(const std::string &prefix, std::deque ¶ms); /** TIME */ bool Time(const std::string &prefix, std::deque ¶ms); /** PING */ bool LocalPing(const std::string &prefix, std::deque ¶ms); /** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes. * This does not update the timestamp of the target channel, this must be done seperately. */ bool RemoveStatus(const std::string &prefix, std::deque ¶ms); /** <- (remote) <- SERVER */ bool RemoteServer(const std::string &prefix, std::deque ¶ms); /** (local) -> SERVER */ bool Outbound_Reply_Server(std::deque ¶ms); /** (local) <- SERVER */ bool Inbound_Server(std::deque ¶ms); /** Handle netsplit */ void Split(const std::string &line, std::deque &n); /** Process complete line from buffer */ bool ProcessLine(std::string &line); /** Get this server's name */ virtual std::string GetName(); /** Handle socket timeout from connect() */ virtual void OnTimeout(); /** Handle socket close event */ virtual void OnClose(); /** Handle incoming connection event */ virtual int OnIncomingConnection(int newsock, char* ip); }; /* Used to validate the value lengths of multiple parameters for a command */ struct cmd_validation { const char* item; size_t param; size_t length; }; /* Used to validate the length values in CAPAB CAPABILITIES */ struct cap_validation { const char* reason; const char* key; size_t size; }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __TREESOCKET_H__ +#define __TREESOCKET_H__ + +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "inspircd.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" + +#include "m_spanningtree/utils.h" + +/* + * The server list in InspIRCd is maintained as two structures + * which hold the data in different ways. Most of the time, we + * want to very quicky obtain three pieces of information: + * + * (1) The information on a server + * (2) The information on the server we must send data through + * to actually REACH the server we're after + * (3) Potentially, the child/parent objects of this server + * + * The InspIRCd spanning protocol provides easy access to these + * by storing the data firstly in a recursive structure, where + * each item references its parent item, and a dynamic list + * of child items, and another structure which stores the items + * hashed, linearly. This means that if we want to find a server + * by name quickly, we can look it up in the hash, avoiding + * 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. + * 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. + * The CONNECTING state indicates an outbound socket which is + * waiting to be writeable. + * The WAIT_AUTH_1 state indicates the socket is outbound and + * has successfully connected, but has not yet sent and received + * SERVER strings. + * The WAIT_AUTH_2 state indicates that the socket is inbound + * (allocated by a LISTENER) but has not yet sent and received + * SERVER strings. + * The CONNECTED state represents a fully authorized, fully + * connected server. + */ +enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED }; + +/** 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 + * for them, just like activex objects on speed. (yes really, that + * is a technical term!) Each of these which relates to a locally + * connected server is assocated with it, by hooking it onto a + * TreeSocket class using its constructor. In this way, we can + * maintain a list of servers, some of which are directly connected, + * some of which are not. + */ +class TreeSocket : public InspSocket +{ + SpanningTreeUtilities* Utils; /* Utility class */ + std::string myhost; /* Canonical hostname */ + std::string in_buffer; /* Input buffer */ + ServerState LinkState; /* Link state */ + std::string InboundServerName; /* Server name sent to us by other side */ + std::string InboundDescription; /* Server description (GECOS) sent to us by the other side */ + int num_lost_users; /* Users lost in split */ + int num_lost_servers; /* Servers lost in split */ + time_t NextPing; /* Time when we are due to ping this server */ + bool LastPingWasGood; /* Responded to last ping we sent? */ + bool bursting; /* True if not finished bursting yet */ + unsigned int keylength; /* Is this still used? */ + std::string ModuleList; /* Module list of other server from CAPAB */ + std::map CapKeys; /* CAPAB keys from other server */ + Module* Hook; /* I/O hooking module that we're attached to for this socket */ + std::string ourchallenge; /* Challenge sent for challenge/response */ + std::string theirchallenge; /* Challenge recv for challenge/response */ + std::string OutboundPass; /* Outbound password */ + bool sentcapab; /* Have sent CAPAB already */ + public: + + /** 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(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, Module* HookMod = NULL); + + /** 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(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Module* HookMod = NULL); + + /** 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(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip, Module* HookMod = NULL); + + /** Get link state + */ + ServerState GetLinkState(); + + /** Get challenge set in our CAPAB for challenge/response + */ + const std::string& GetOurChallenge(); + + /** Get challenge set in our CAPAB for challenge/response + */ + void SetOurChallenge(const std::string &c); + + /** Get challenge set in their CAPAB for challenge/response + */ + const std::string& GetTheirChallenge(); + + /** Get challenge set in their CAPAB for challenge/response + */ + void SetTheirChallenge(const std::string &c); + + /** Compare two passwords based on authentication scheme + */ + bool ComparePass(const std::string &ours, const std::string &theirs); + + /** Return the module which we are hooking to for I/O encapsulation + */ + Module* GetHook(); + + /** Destructor + */ + ~TreeSocket(); + + /** Generate random string used for challenge-response auth + */ + std::string RandString(unsigned int length); + + /** Construct a password, optionally hashed with the other side's + * challenge string + */ + std::string MakePass(const std::string &password, const std::string &challenge); + + /** 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 + * will then send back its own server string. + */ + virtual bool OnConnected(); + + /** Handle socket error event + */ + virtual void OnError(InspSocketError e); + + /** Sends an error to the remote server, and displays it locally to show + * that it was sent. + */ + void SendError(const std::string &errormessage); + + /** Handle socket disconnect event + */ + virtual int OnDisconnect(); + + /** 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 + * end, our connection may be terminated. The hopcounts given + * by this function are relative, this doesn't matter so long as + * they are all >1, as all the remote servers re-calculate them + * to be relative too, with themselves as hop 0. + */ + void SendServers(TreeServer* Current, TreeServer* s, int hops); + + /** Returns my capabilities as a string + */ + std::string MyCapabilities(); + + /** Send my capabilities to the remote side + */ + void SendCapabilities(); + + /* Check a comma seperated list for an item */ + bool HasItem(const std::string &list, const std::string &item); + + /* Isolate and return the elements that are different between two comma seperated lists */ + std::string ListDifference(const std::string &one, const std::string &two); + + bool Capab(const std::deque ¶ms); + + /** 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 + * too many times a month ;-) + */ + void SquitServer(std::string &from, TreeServer* Current); + + /** 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, const std::string &reason); + + /** FMODE command - server mode with timestamp checks */ + bool ForceMode(const std::string &source, std::deque ¶ms); + + /** FTOPIC command */ + bool ForceTopic(const std::string &source, std::deque ¶ms); + + /** FJOIN, similar to TS6 SJOIN, but not quite. */ + bool ForceJoin(const std::string &source, std::deque ¶ms); + + /** NICK command */ + bool IntroduceClient(const std::string &source, std::deque ¶ms); + + /** 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. + */ + void SendFJoins(TreeServer* Current, chanrec* c); + + /** Send G, Q, Z and E lines */ + void SendXLines(TreeServer* Current); + + /** Send channel modes and topics */ + void SendChannelModes(TreeServer* Current); + + /** send all users and their oper state/modes */ + void SendUsers(TreeServer* Current); + + /** 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. + */ + void DoBurst(TreeServer* s); + + /** 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. + * + * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES + * THE SOCKET OBJECT FOR US. + */ + virtual bool OnDataReady(); + + /** Send one or more complete lines down the socket + */ + int WriteLine(std::string line); + + /** Handle ERROR command */ + bool Error(std::deque ¶ms); + + /** remote MOTD. leet, huh? */ + bool Motd(const std::string &prefix, std::deque ¶ms); + + /** remote ADMIN. leet, huh? */ + bool Admin(const std::string &prefix, std::deque ¶ms); + + /** Remote MODULES */ + bool Modules(const std::string &prefix, std::deque ¶ms); + + bool Stats(const std::string &prefix, std::deque ¶ms); + + /** Because the core won't let users or even SERVERS set +o, + * we use the OPERTYPE command to do this. + */ + bool OperType(const std::string &prefix, std::deque ¶ms); + + /** Because Andy insists that services-compatible servers must + * implement SVSNICK and SVSJOIN, that's exactly what we do :p + */ + bool ForceNick(const std::string &prefix, std::deque ¶ms); + + bool OperQuit(const std::string &prefix, std::deque ¶ms); + + /** SVSJOIN + */ + bool ServiceJoin(const std::string &prefix, std::deque ¶ms); + + /** REHASH + */ + bool RemoteRehash(const std::string &prefix, std::deque ¶ms); + + /** KILL + */ + bool RemoteKill(const std::string &prefix, std::deque ¶ms); + + /** PONG + */ + bool LocalPong(const std::string &prefix, std::deque ¶ms); + + /** METADATA + */ + bool MetaData(const std::string &prefix, std::deque ¶ms); + + /** VERSION + */ + bool ServerVersion(const std::string &prefix, std::deque ¶ms); + + /** CHGHOST + */ + bool ChangeHost(const std::string &prefix, std::deque ¶ms); + + /** ADDLINE + */ + bool AddLine(const std::string &prefix, std::deque ¶ms); + + /** CHGNAME + */ + bool ChangeName(const std::string &prefix, std::deque ¶ms); + + /** WHOIS + */ + bool Whois(const std::string &prefix, std::deque ¶ms); + + /** PUSH + */ + bool Push(const std::string &prefix, std::deque ¶ms); + + /** SETTIME + */ + bool HandleSetTime(const std::string &prefix, std::deque ¶ms); + + /** TIME + */ + bool Time(const std::string &prefix, std::deque ¶ms); + + /** PING + */ + bool LocalPing(const std::string &prefix, std::deque ¶ms); + + /** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes. + * This does not update the timestamp of the target channel, this must be done seperately. + */ + bool RemoveStatus(const std::string &prefix, std::deque ¶ms); + + /** <- (remote) <- SERVER + */ + bool RemoteServer(const std::string &prefix, std::deque ¶ms); + + /** (local) -> SERVER + */ + bool Outbound_Reply_Server(std::deque ¶ms); + + /** (local) <- SERVER + */ + bool Inbound_Server(std::deque ¶ms); + + /** Handle netsplit + */ + void Split(const std::string &line, std::deque &n); + + /** Process complete line from buffer + */ + bool ProcessLine(std::string &line); + + /** Get this server's name + */ + virtual std::string GetName(); + + /** Handle socket timeout from connect() + */ + virtual void OnTimeout(); + + /** Handle socket close event + */ + virtual void OnClose(); + + /** Handle incoming connection event + */ + virtual int OnIncomingConnection(int newsock, char* ip); +}; + +/* Used to validate the value lengths of multiple parameters for a command */ +struct cmd_validation +{ + const char* item; + size_t param; + size_t length; +}; + +/* Used to validate the length values in CAPAB CAPABILITIES */ +struct cap_validation +{ + const char* reason; + const char* key; + size_t size; +}; + +#endif + diff --git a/src/modules/m_spanningtree/treesocket1.cpp b/src/modules/m_spanningtree/treesocket1.cpp index ad2588cab..a907bb440 100644 --- a/src/modules/m_spanningtree/treesocket1.cpp +++ b/src/modules/m_spanningtree/treesocket1.cpp @@ -1 +1,1273 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "m_hash.h" #include "socketengine.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" #include "m_spanningtree/resolvers.h" #include "m_spanningtree/handshaketimer.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_hash.h */ /** 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::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, Module* HookMod) : InspSocket(SI, host, port, listening, maxtime), Utils(Util), Hook(HookMod) { myhost = host; this->LinkState = LISTENER; theirchallenge.clear(); ourchallenge.clear(); if (listening && Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); } TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Module* HookMod) : InspSocket(SI, host, port, listening, maxtime, bindto), Utils(Util), Hook(HookMod) { myhost = ServerName; theirchallenge.clear(); ourchallenge.clear(); this->LinkState = CONNECTING; if (Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); } /** 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::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip, Module* HookMod) : InspSocket(SI, newfd, ip), Utils(Util), Hook(HookMod) { this->LinkState = WAIT_AUTH_1; theirchallenge.clear(); ourchallenge.clear(); sentcapab = false; /* If we have a transport module hooked to the parent, hook the same module to this * socket, and set a timer waiting for handshake before we send CAPAB etc. */ if (Hook) InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils, 1)); } ServerState TreeSocket::GetLinkState() { return this->LinkState; } Module* TreeSocket::GetHook() { return this->Hook; } TreeSocket::~TreeSocket() { if (Hook) InspSocketUnhookRequest(this, (Module*)Utils->Creator, Hook).Send(); Utils->DelBurstingServer(this); } const std::string& TreeSocket::GetOurChallenge() { return this->ourchallenge; } void TreeSocket::SetOurChallenge(const std::string &c) { this->ourchallenge = c; } const std::string& TreeSocket::GetTheirChallenge() { return this->theirchallenge; } void TreeSocket::SetTheirChallenge(const std::string &c) { this->theirchallenge = c; } std::string TreeSocket::MakePass(const std::string &password, const std::string &challenge) { /* This is a simple (maybe a bit hacky?) HMAC algorithm, thanks to jilles for * suggesting the use of HMAC to secure the password against various attacks. * * Note: If m_sha256.so is not loaded, we MUST fall back to plaintext with no * HMAC challenge/response. */ Module* sha256 = Instance->FindModule("m_sha256.so"); if (Utils->ChallengeResponse && sha256 && !challenge.empty()) { /* XXX: This is how HMAC is supposed to be done: * * sha256( (pass xor 0x5c) + sha256((pass xor 0x36) + m) ) * * Note that we are encoding the hex hash, not the binary * output of the hash which is slightly different to standard. * * Don't ask me why its always 0x5c and 0x36... it just is. */ std::string hmac1, hmac2; for (size_t n = 0; n < password.length(); n++) { hmac1 += static_cast(password[n] ^ 0x5C); hmac2 += static_cast(password[n] ^ 0x36); } hmac2 += challenge; HashResetRequest(Utils->Creator, sha256).Send(); hmac2 = HashSumRequest(Utils->Creator, sha256, hmac2).Send(); HashResetRequest(Utils->Creator, sha256).Send(); std::string hmac = hmac1 + hmac2; hmac = HashSumRequest(Utils->Creator, sha256, hmac).Send(); return "HMAC-SHA256:"+ hmac; } else if (!challenge.empty() && !sha256) Instance->Log(DEFAULT,"Not authenticating to server using SHA256/HMAC because we don't have m_sha256 loaded!"); return password; } /** 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 * will then send back its own server string. */ bool TreeSocket::OnConnected() { if (this->LinkState == CONNECTING) { /* we do not need to change state here. */ 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())+"] started."); if (Hook) { InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] using transport \2"+x->Hook+"\2"); } this->OutboundPass = x->SendPass; sentcapab = false; /* found who we're supposed to be connecting to, send the neccessary gubbins. */ if (this->GetHook()) Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(*x), this->Utils, 1)); else this->SendCapabilities(); return true; } } } /* There is a (remote) chance that between the /CONNECT and the connection * being accepted, some muppet has removed the block and rehashed. * If that happens the connection hangs here until it's closed. Unlikely * and rather harmless. */ this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2 lost link tag(!)"); return true; } void TreeSocket::OnError(InspSocketError e) { Link* MyLink; switch (e) { case I_ERR_CONNECT: this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused"); MyLink = Utils->FindLink(myhost); if (MyLink) Utils->DoFailOver(MyLink); break; case I_ERR_SOCKET: this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Could not create socket"); break; case I_ERR_BIND: this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Error binding socket to address or port"); break; case I_ERR_WRITE: this->Instance->SNO->WriteToSnoMask('l',"Connection failed: I/O error on connection"); break; case I_ERR_NOMOREFDS: this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Operating system is out of file descriptors!"); break; default: if ((errno) && (errno != EINPROGRESS) && (errno != EAGAIN)) { std::string errstr = strerror(errno); this->Instance->SNO->WriteToSnoMask('l',"Connection to \002"+myhost+"\002 failed with OS error: " + errstr); } break; } } int TreeSocket::OnDisconnect() { /* For the same reason as above, we don't * handle OnDisconnect() */ return true; } /** 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 * end, our connection may be terminated. The hopcounts given * by this function are relative, this doesn't matter so long as * they are all >1, as all the remote servers re-calculate them * to be relative too, with themselves as hop 0. */ void TreeSocket::SendServers(TreeServer* Current, TreeServer* s, int hops) { char command[1024]; for (unsigned int q = 0; q < Current->ChildCount(); q++) { TreeServer* recursive_server = Current->GetChild(q); if (recursive_server != s) { snprintf(command,1024,":%s SERVER %s * %d :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops,recursive_server->GetDesc().c_str()); this->WriteLine(command); this->WriteLine(":"+recursive_server->GetName()+" VERSION :"+recursive_server->GetVersion()); /* down to next level */ this->SendServers(recursive_server, s, hops+1); } } } std::string TreeSocket::MyCapabilities() { std::vector modlist; std::string capabilities; for (int i = 0; i <= this->Instance->GetModuleCount(); i++) { if (this->Instance->modules[i]->GetVersion().Flags & VF_COMMON) modlist.push_back(this->Instance->Config->module_names[i]); } sort(modlist.begin(),modlist.end()); for (unsigned int i = 0; i < modlist.size(); i++) { if (i) capabilities = capabilities + ","; capabilities = capabilities + modlist[i]; } return capabilities; } std::string TreeSocket::RandString(unsigned int length) { char* randombuf = new char[length+1]; std::string out; #ifdef WINDOWS int fd = -1; #else int fd = open("/dev/urandom", O_RDONLY, 0); #endif if (fd >= 0) { #ifndef WINDOWS read(fd, randombuf, length); close(fd); #endif } else { for (unsigned int i = 0; i < length; i++) randombuf[i] = rand(); } for (unsigned int i = 0; i < length; i++) { char randchar = static_cast((randombuf[i] & 0x7F) | 0x21); out += (randchar == '=' ? '_' : randchar); } delete[] randombuf; return out; } void TreeSocket::SendCapabilities() { if (sentcapab) return; sentcapab = true; irc::commasepstream modulelist(MyCapabilities()); this->WriteLine("CAPAB START"); /* Send module names, split at 509 length */ std::string item = "*"; std::string line = "CAPAB MODULES "; while ((item = modulelist.GetToken()) != "") { if (line.length() + item.length() + 1 > 509) { this->WriteLine(line); line = "CAPAB MODULES "; } if (line != "CAPAB MODULES ") line.append(","); line.append(item); } if (line != "CAPAB MODULES ") this->WriteLine(line); int ip6 = 0; int ip6support = 0; #ifdef IPV6 ip6 = 1; #endif #ifdef SUPPORT_IP6LINKS ip6support = 1; #endif std::string extra; /* Do we have sha256 available? If so, we send a challenge */ if (Utils->ChallengeResponse && (Instance->FindModule("m_sha256.so"))) { this->SetOurChallenge(RandString(20)); extra = " CHALLENGE=" + this->GetOurChallenge(); } this->WriteLine("CAPAB CAPABILITIES :NICKMAX="+ConvToStr(NICKMAX)+" HALFOP="+ConvToStr(this->Instance->Config->AllowHalfop)+" CHANMAX="+ConvToStr(CHANMAX)+" MAXMODES="+ConvToStr(MAXMODES)+" IDENTMAX="+ConvToStr(IDENTMAX)+" MAXQUIT="+ConvToStr(MAXQUIT)+" MAXTOPIC="+ConvToStr(MAXTOPIC)+" MAXKICK="+ConvToStr(MAXKICK)+" MAXGECOS="+ConvToStr(MAXGECOS)+" MAXAWAY="+ConvToStr(MAXAWAY)+" IP6NATIVE="+ConvToStr(ip6)+" IP6SUPPORT="+ConvToStr(ip6support)+" PROTOCOL="+ConvToStr(ProtocolVersion)+extra+" PREFIX="+Instance->Modes->BuildPrefixes()+" CHANMODES="+Instance->Modes->ChanModes()); this->WriteLine("CAPAB END"); } /* Check a comma seperated list for an item */ bool TreeSocket::HasItem(const std::string &list, const std::string &item) { irc::commasepstream seplist(list); std::string item2 = "*"; while ((item2 = seplist.GetToken()) != "") { if (item2 == item) return true; } return false; } /* Isolate and return the elements that are different between two comma seperated lists */ std::string TreeSocket::ListDifference(const std::string &one, const std::string &two) { irc::commasepstream list_one(one); std::string item = "*"; std::string result; while ((item = list_one.GetToken()) != "") { if (!HasItem(two, item)) { result.append(" "); result.append(item); } } return result; } void TreeSocket::SendError(const std::string &errormessage) { /* Display the error locally as well as sending it remotely */ this->WriteLine("ERROR :"+errormessage); this->Instance->SNO->WriteToSnoMask('l',"Sent \2ERROR\2 to "+this->InboundServerName+": "+errormessage); /* One last attempt to make sure the error reaches its target */ this->FlushWriteBuffer(); } bool TreeSocket::Capab(const std::deque ¶ms) { if (params.size() < 1) { this->SendError("Invalid number of parameters for CAPAB - Mismatched version"); return false; } if (params[0] == "START") { this->ModuleList.clear(); this->CapKeys.clear(); } else if (params[0] == "END") { std::string reason; int ip6support = 0; #ifdef SUPPORT_IP6LINKS ip6support = 1; #endif /* Compare ModuleList and check CapKeys... * Maybe this could be tidier? -- Brain */ if ((this->ModuleList != this->MyCapabilities()) && (this->ModuleList.length())) { std::string diff = ListDifference(this->ModuleList, this->MyCapabilities()); if (!diff.length()) { diff = "your server:" + ListDifference(this->MyCapabilities(), this->ModuleList); } else { diff = "this server:" + diff; } if (diff.length() == 12) reason = "Module list in CAPAB is not alphabetically ordered, cannot compare lists."; else reason = "Modules loaded on these servers are not correctly matched, these modules are not loaded on " + diff; } cap_validation valid_capab[] = { {"Maximum nickname lengths differ or remote nickname length not specified", "NICKMAX", NICKMAX}, {"Maximum ident lengths differ or remote ident length not specified", "IDENTMAX", IDENTMAX}, {"Maximum channel lengths differ or remote channel length not specified", "CHANMAX", CHANMAX}, {"Maximum modes per line differ or remote modes per line not specified", "MAXMODES", MAXMODES}, {"Maximum quit lengths differ or remote quit length not specified", "MAXQUIT", MAXQUIT}, {"Maximum topic lengths differ or remote topic length not specified", "MAXTOPIC", MAXTOPIC}, {"Maximum kick lengths differ or remote kick length not specified", "MAXKICK", MAXKICK}, {"Maximum GECOS (fullname) lengths differ or remote GECOS length not specified", "MAXGECOS", MAXGECOS}, {"Maximum awaymessage lengths differ or remote awaymessage length not specified", "MAXAWAY", MAXAWAY}, {"", "", 0} }; if (((this->CapKeys.find("IP6SUPPORT") == this->CapKeys.end()) && (ip6support)) || ((this->CapKeys.find("IP6SUPPORT") != this->CapKeys.end()) && (this->CapKeys.find("IP6SUPPORT")->second != ConvToStr(ip6support)))) reason = "We don't both support linking to IPV6 servers"; if (((this->CapKeys.find("IP6NATIVE") != this->CapKeys.end()) && (this->CapKeys.find("IP6NATIVE")->second == "1")) && (!ip6support)) reason = "The remote server is IPV6 native, and we don't support linking to IPV6 servers"; if (((this->CapKeys.find("PROTOCOL") == this->CapKeys.end()) || ((this->CapKeys.find("PROTOCOL") != this->CapKeys.end()) && (this->CapKeys.find("PROTOCOL")->second != ConvToStr(ProtocolVersion))))) { if (this->CapKeys.find("PROTOCOL") != this->CapKeys.end()) reason = "Mismatched protocol versions "+this->CapKeys.find("PROTOCOL")->second+" and "+ConvToStr(ProtocolVersion); else reason = "Protocol version not specified"; } if(this->CapKeys.find("PREFIX") != this->CapKeys.end() && this->CapKeys.find("PREFIX")->second != this->Instance->Modes->BuildPrefixes()) reason = "One or more of the prefixes on the remote server are invalid on this server."; if (((this->CapKeys.find("HALFOP") == this->CapKeys.end()) && (Instance->Config->AllowHalfop)) || ((this->CapKeys.find("HALFOP") != this->CapKeys.end()) && (this->CapKeys.find("HALFOP")->second != ConvToStr(Instance->Config->AllowHalfop)))) reason = "We don't both have halfop support enabled/disabled identically"; for (int x = 0; valid_capab[x].size; ++x) { if (((this->CapKeys.find(valid_capab[x].key) == this->CapKeys.end()) || ((this->CapKeys.find(valid_capab[x].key) != this->CapKeys.end()) && (this->CapKeys.find(valid_capab[x].key)->second != ConvToStr(valid_capab[x].size))))) reason = valid_capab[x].reason; } /* Challenge response, store their challenge for our password */ std::map::iterator n = this->CapKeys.find("CHALLENGE"); if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->FindModule("m_sha256.so"))) { /* Challenge-response is on now */ this->SetTheirChallenge(n->second); if (!this->GetTheirChallenge().empty() && (this->LinkState == CONNECTING)) { this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc); } } else { /* They didnt specify a challenge or we don't have m_sha256.so, we use plaintext */ if (this->LinkState == CONNECTING) this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+OutboundPass+" 0 :"+this->Instance->Config->ServerDesc); } if (reason.length()) { this->SendError("CAPAB negotiation failed: "+reason); return false; } } else if ((params[0] == "MODULES") && (params.size() == 2)) { if (!this->ModuleList.length()) { this->ModuleList.append(params[1]); } else { this->ModuleList.append(","); this->ModuleList.append(params[1]); } } else if ((params[0] == "CAPABILITIES") && (params.size() == 2)) { irc::tokenstream capabs(params[1]); std::string item; bool more = true; while ((more = capabs.GetToken(item))) { /* Process each key/value pair */ std::string::size_type equals = item.rfind('='); if (equals != std::string::npos) { std::string var = item.substr(0, equals); std::string value = item.substr(equals+1, item.length()); CapKeys[var] = value; } } } return true; } /** 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 * too many times a month ;-) */ void TreeSocket::SquitServer(std::string &from, TreeServer* Current) { /* recursively squit the servers attached to 'Current'. * We're going backwards so we don't remove users * while we still need them ;) */ for (unsigned int q = 0; q < Current->ChildCount(); q++) { TreeServer* recursive_server = Current->GetChild(q); this->SquitServer(from,recursive_server); } /* Now we've whacked the kids, whack self */ num_lost_servers++; num_lost_users += Current->QuitUsers(from); } /** This is a wrapper function for SquitServer above, which * does some validation first and passes on the SQUIT to all * other remaining servers. */ void TreeSocket::Squit(TreeServer* Current, const std::string &reason) { if ((Current) && (Current != Utils->TreeRoot)) { Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server"); rmode.Send(Instance); std::deque params; params.push_back(Current->GetName()); params.push_back(":"+reason); Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName()); if (Current->GetParent() == Utils->TreeRoot) { this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split: "+reason); } else { this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason); } num_lost_servers = 0; num_lost_users = 0; std::string from = Current->GetParent()->GetName()+" "+Current->GetName(); SquitServer(from, Current); Current->Tidy(); Current->GetParent()->DelChild(Current); DELETE(Current); this->Instance->SNO->WriteToSnoMask('l',"Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers); } else Instance->Log(DEFAULT,"Squit from unknown server"); } /** FMODE command - server mode with timestamp checks */ bool TreeSocket::ForceMode(const std::string &source, std::deque ¶ms) { /* Chances are this is a 1.0 FMODE without TS */ if (params.size() < 3) { /* No modes were in the command, probably a channel with no modes set on it */ return true; } bool smode = false; std::string sourceserv; /* Are we dealing with an FMODE from a user, or from a server? */ userrec* who = this->Instance->FindNick(source); if (who) { /* FMODE from a user, set sourceserv to the users server name */ sourceserv = who->server; } else { /* FMODE from a server, create a fake user to receive mode feedback */ who = new userrec(this->Instance); who->SetFd(FD_MAGIC_NUMBER); smode = true; /* Setting this flag tells us we should free the userrec later */ sourceserv = source; /* Set sourceserv to the actual source string */ } const char* modelist[64]; time_t TS = 0; int n = 0; memset(&modelist,0,sizeof(modelist)); for (unsigned int q = 0; (q < params.size()) && (q < 64); q++) { if (q == 1) { /* The timestamp is in this position. * We don't want to pass that up to the * server->client protocol! */ TS = atoi(params[q].c_str()); } else { /* Everything else is fine to append to the modelist */ modelist[n++] = params[q].c_str(); } } /* Extract the TS value of the object, either userrec or chanrec */ userrec* dst = this->Instance->FindNick(params[0]); chanrec* chan = NULL; time_t ourTS = 0; if (dst) { ourTS = dst->age; } else { chan = this->Instance->FindChan(params[0]); if (chan) { ourTS = chan->age; } else /* Oops, channel doesnt exist! */ return true; } if (!TS) { Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FMODE. Are some services authors smoking craq, or is it 1970 again?. Dropped."); Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FMODE with a TS of zero. Total craq. Mode was dropped.", sourceserv.c_str()); return true; } /* TS is equal or less: Merge the mode changes into ours and pass on. */ if (TS <= ourTS) { if ((TS < ourTS) && (!dst)) Instance->Log(DEFAULT,"*** BUG *** Channel TS sent in FMODE to %s is %lu which is not equal to %lu!", params[0].c_str(), TS, ourTS); if (smode) { this->Instance->SendMode(modelist, n, who); } else { this->Instance->CallCommandHandler("MODE", modelist, n, who); } /* HOT POTATO! PASS IT ON! */ Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv); } /* If the TS is greater than ours, we drop the mode and dont pass it anywhere. */ if (smode) DELETE(who); return true; } /** FTOPIC command */ bool TreeSocket::ForceTopic(const std::string &source, std::deque ¶ms) { if (params.size() != 4) return true; time_t ts = atoi(params[1].c_str()); std::string nsource = source; chanrec* c = this->Instance->FindChan(params[0]); if (c) { if ((ts >= c->topicset) || (!*c->topic)) { std::string oldtopic = c->topic; strlcpy(c->topic,params[3].c_str(),MAXTOPIC); strlcpy(c->setby,params[2].c_str(),127); c->topicset = ts; /* if the topic text is the same as the current topic, * dont bother to send the TOPIC command out, just silently * update the set time and set nick. */ if (oldtopic != params[3]) { userrec* user = this->Instance->FindNick(source); if (!user) { c->WriteChannelWithServ(Instance->Config->ServerName, "TOPIC %s :%s", c->name, c->topic); } else { c->WriteChannel(user, "TOPIC %s :%s", c->name, c->topic); nsource = user->server; } /* all done, send it on its way */ params[3] = ":" + params[3]; Utils->DoOneToAllButSender(source,"FTOPIC",params,nsource); } } } return true; } /** FJOIN, similar to TS6 SJOIN, but not quite. */ bool TreeSocket::ForceJoin(const 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 of its * modes from the channel, before introducing new users into the channel * which are listed in the FJOIN command's parameters. 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 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; irc::modestacker modestack(true); /* Modes to apply from the users in the user list */ 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 */ irc::tokenstream users(params[2]); /* Users from the user list */ bool apply_other_sides_modes = true; /* True if we are accepting the other side's modes */ chanrec* chan = this->Instance->FindChan(channel); /* The channel we're sending joins to */ time_t ourTS = chan ? chan->age : Instance->Time(true)+600; /* The TS of our side of the link */ bool created = !chan; /* True if the channel doesnt exist here yet */ std::string item; /* One item in the list of nicks */ params[2] = ":" + params[2]; Utils->DoOneToAllButSender(source,"FJOIN",params,source); if (!TS) { Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FJOIN. Are some services authors smoking craq, or is it 1970 again?. Dropped."); Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FJOIN with a TS of zero. Total craq. Command was dropped.", source.c_str()); return true; } /* If our TS is less than theirs, we dont accept their modes */ if (ourTS < TS) apply_other_sides_modes = false; /* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */ if (ourTS > TS) { std::deque param_list; if (Utils->AnnounceTSChange && chan) chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS); ourTS = TS; if (!created) { chan->age = TS; param_list.push_back(channel); this->RemoveStatus(Instance->Config->ServerName, param_list); } } /* Now, process every 'prefixes,nick' pair */ while (users.GetToken(item)) { const char* usr = item.c_str(); if (usr && *usr) { const char* permissions = usr; /* Iterate through all the prefix values, convert them from prefixes to mode letters */ std::string modes; while ((*permissions) && (*permissions != ',')) { ModeHandler* mh = Instance->Modes->FindPrefix(*permissions); if (mh) modes = modes + mh->GetModeChar(); else { this->SendError(std::string("Invalid prefix '")+(*permissions)+"' in FJOIN"); return false; } usr++; permissions++; } /* Advance past the comma, to the nick */ usr++; /* Check the user actually exists */ who = this->Instance->FindNick(usr); if (who) { /* Check that the user's 'direction' is correct */ TreeServer* route_back_again = Utils->BestRouteTo(who->server); if ((!route_back_again) || (route_back_again->GetSocket() != this)) continue; /* Add any permissions this user had to the mode stack */ for (std::string::iterator x = modes.begin(); x != modes.end(); ++x) modestack.Push(*x, who->nick); chanrec::JoinUser(this->Instance, who, channel.c_str(), true, "", TS); } else { Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", usr, channel.c_str()); continue; } } } /* Flush mode stacker if we lost the FJOIN or had equal TS */ if (apply_other_sides_modes) { std::deque stackresult; const char* mode_junk[MAXMODES+2]; userrec* n = new userrec(Instance); n->SetFd(FD_MAGIC_NUMBER); mode_junk[0] = channel.c_str(); while (modestack.GetStackedLine(stackresult)) { for (size_t j = 0; j < stackresult.size(); j++) { mode_junk[j+1] = stackresult[j].c_str(); } Instance->SendMode(mode_junk, stackresult.size() + 1, n); } delete n; } return true; } /** NICK command */ bool TreeSocket::IntroduceClient(const std::string &source, std::deque ¶ms) { /** Do we have enough parameters: * NICK age nick host dhost ident +modes ip :gecos */ if (params.size() != 8) { this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)"); return true; } time_t age = ConvToInt(params[0]); const char* tempnick = params[1].c_str(); cmd_validation valid[] = { {"Nickname", 1, NICKMAX}, {"Hostname", 2, 64}, {"Displayed hostname", 3, 64}, {"Ident", 4, IDENTMAX}, {"GECOS", 7, MAXGECOS}, {"", 0, 0} }; TreeServer* remoteserver = Utils->FindServer(source); if (!remoteserver) { this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Unknown server "+source+")"); return true; } /* Check parameters for validity before introducing the client, discovered by dmb */ if (!age) { this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Invalid TS?)"); return true; } for (size_t x = 0; valid[x].length; ++x) { if (params[valid[x].param].length() > valid[x].length) { this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (" + valid[x].item + " > " + ConvToStr(valid[x].length) + ")"); return true; } } /** Our client looks ok, lets introduce it now */ Instance->Log(DEBUG,"New remote client %s",tempnick); user_hash::iterator iter = this->Instance->clientlist->find(tempnick); if (iter != this->Instance->clientlist->end()) { /* nick collision */ this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+tempnick+" :Nickname collision"); userrec::QuitUser(this->Instance, iter->second, "Nickname collision"); return true; } userrec* _new = new userrec(this->Instance); (*(this->Instance->clientlist))[tempnick] = _new; _new->SetFd(FD_MAGIC_NUMBER); strlcpy(_new->nick, tempnick,NICKMAX-1); strlcpy(_new->host, params[2].c_str(),64); strlcpy(_new->dhost, params[3].c_str(),64); _new->server = this->Instance->FindServerNamePtr(source.c_str()); strlcpy(_new->ident, params[4].c_str(),IDENTMAX); strlcpy(_new->fullname, params[7].c_str(),MAXGECOS); _new->registered = REG_ALL; _new->signon = age; /* we need to remove the + from the modestring, so we can do our stuff */ std::string::size_type pos_after_plus = params[5].find_first_not_of('+'); if (pos_after_plus != std::string::npos) params[5] = params[5].substr(pos_after_plus); for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++) { _new->modes[(*v)-65] = 1; /* For each mode thats set, increase counter */ ModeHandler* mh = Instance->Modes->FindMode(*v, MODETYPE_USER); if (mh) mh->ChangeCount(1); } /* now we've done with modes processing, put the + back for remote servers */ params[5] = "+" + params[5]; #ifdef SUPPORT_IP6LINKS if (params[6].find_first_of(":") != std::string::npos) _new->SetSockAddr(AF_INET6, params[6].c_str(), 0); else #endif _new->SetSockAddr(AF_INET, params[6].c_str(), 0); Instance->AddGlobalClone(_new); bool dosend = !(((this->Utils->quiet_bursts) && (this->bursting || Utils->FindRemoteBurstServer(remoteserver))) || (this->Instance->SilentULine(_new->server))); if (dosend) this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s] [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString(), _new->fullname); params[7] = ":" + params[7]; Utils->DoOneToAllButSender(source,"NICK", params, source); // Increment the Source Servers User Count.. TreeServer* SourceServer = Utils->FindServer(source); if (SourceServer) { SourceServer->AddUserCount(); } FOREACH_MOD_I(Instance,I_OnPostConnect,OnPostConnect(_new)); return true; } /** 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. */ void TreeSocket::SendFJoins(TreeServer* Current, chanrec* c) { std::string buffer; char list[MAXBUF]; std::string individual_halfops = std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age); size_t dlen, curlen; dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age); int numusers = 0; char* ptr = list + dlen; CUList *ulist = c->GetUsers(); std::string modes; std::string params; for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { // The first parameter gets a : before it size_t ptrlen = snprintf(ptr, MAXBUF, " %s%s,%s", !numusers ? ":" : "", c->GetAllPrefixChars(i->first), i->first->nick); curlen += ptrlen; ptr += ptrlen; numusers++; if (curlen > (480-NICKMAX)) { buffer.append(list).append("\r\n"); dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age); ptr = list + dlen; ptrlen = 0; numusers = 0; } } if (numusers) buffer.append(list).append("\r\n"); buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(c->ChanModes(true)).append("\r\n"); int linesize = 1; for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++) { int size = strlen(b->data) + 2; int currsize = linesize + size; if (currsize <= 350) { modes.append("b"); params.append(" ").append(b->data); linesize += size; } if ((params.length() >= MAXMODES) || (currsize > 350)) { /* Wrap at MAXMODES */ buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params).append("\r\n"); modes.clear(); params.clear(); linesize = 1; } } /* Only send these if there are any */ if (!modes.empty()) buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params); this->WriteLine(buffer); } /** Send G, Q, Z and E lines */ void TreeSocket::SendXLines(TreeServer* Current) { char data[MAXBUF]; std::string buffer; std::string n = this->Instance->Config->ServerName; const char* sn = n.c_str(); /* 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++) { snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } for (std::vector::iterator i = Instance->XLines->qlines.begin(); i != Instance->XLines->qlines.end(); i++) { snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } for (std::vector::iterator i = Instance->XLines->glines.begin(); i != Instance->XLines->glines.end(); i++) { snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } for (std::vector::iterator i = Instance->XLines->elines.begin(); i != Instance->XLines->elines.end(); i++) { snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } for (std::vector::iterator i = Instance->XLines->pzlines.begin(); i != Instance->XLines->pzlines.end(); i++) { snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } for (std::vector::iterator i = Instance->XLines->pqlines.begin(); i != Instance->XLines->pqlines.end(); i++) { snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } for (std::vector::iterator i = Instance->XLines->pglines.begin(); i != Instance->XLines->pglines.end(); i++) { snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } for (std::vector::iterator i = Instance->XLines->pelines.begin(); i != Instance->XLines->pelines.end(); i++) { snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); buffer.append(data); } if (!buffer.empty()) this->WriteLine(buffer); } /** Send channel modes and topics */ void TreeSocket::SendChannelModes(TreeServer* Current) { char data[MAXBUF]; std::deque list; std::string n = this->Instance->Config->ServerName; const char* sn = n.c_str(); Instance->Log(DEBUG,"Sending channels and modes, %d to send", this->Instance->chanlist->size()); for (chan_hash::iterator c = this->Instance->chanlist->begin(); c != this->Instance->chanlist->end(); c++) { SendFJoins(Current, c->second); if (*c->second->topic) { 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*)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*)Utils->Creator,(void*)this,list[j])); } } } /** send all users and their oper state/modes */ void TreeSocket::SendUsers(TreeServer* Current) { char data[MAXBUF]; std::deque list; std::string dataline; for (user_hash::iterator u = this->Instance->clientlist->begin(); u != this->Instance->clientlist->end(); u++) { if (u->second->registered == REG_ALL) { snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->FormatModes(),u->second->GetIPString(),u->second->fullname); this->WriteLine(data); if (*u->second->oper) { snprintf(data,MAXBUF,":%s OPERTYPE %s", u->second->nick, u->second->oper); this->WriteLine(data); } if (*u->second->awaymsg) { snprintf(data,MAXBUF,":%s AWAY :%s", u->second->nick, u->second->awaymsg); this->WriteLine(data); } } } for (user_hash::iterator u = this->Instance->clientlist->begin(); u != this->Instance->clientlist->end(); u++) { 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*)Utils->Creator,(void*)this,list[j])); } } } /** 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. */ void TreeSocket::DoBurst(TreeServer* s) { std::string name = s->GetName(); std::string burst = "BURST "+ConvToStr(Instance->Time(true)); std::string endburst = "ENDBURST"; this->Instance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s).", name.c_str(), this->GetTheirChallenge().empty() ? "plaintext password" : "SHA256-HMAC challenge-response"); this->WriteLine(burst); /* send our version string */ this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" VERSION :"+this->Instance->GetVersionString()); /* Send server tree */ 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*)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 * 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. * * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES * THE SOCKET OBJECT FOR US. */ bool TreeSocket::OnDataReady() { char* data = this->Read(); /* Check that the data read is a valid pointer and it has some content */ if (data && *data) { this->in_buffer.append(data); /* While there is at least one new line in the buffer, * do something useful (we hope!) with it. */ while (in_buffer.find("\n") != std::string::npos) { std::string ret = in_buffer.substr(0,in_buffer.find("\n")-1); in_buffer = in_buffer.substr(in_buffer.find("\n")+1,in_buffer.length()-in_buffer.find("\n")); /* Use rfind here not find, as theres more * chance of the \r being near the end of the * string, not the start. */ if (ret.find("\r") != std::string::npos) ret = in_buffer.substr(0,in_buffer.find("\r")-1); /* Process this one, abort if it * didnt return true. */ if (!this->ProcessLine(ret)) { return false; } } return true; } /* EAGAIN returns an empty but non-NULL string, so this * evaluates to TRUE for EAGAIN but to FALSE for EOF. */ return (data && !*data); } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" +#include "m_hash.h" +#include "socketengine.h" + +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" +#include "m_spanningtree/resolvers.h" +#include "m_spanningtree/handshaketimer.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_hash.h */ + + +/** 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::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, Module* HookMod) + : InspSocket(SI, host, port, listening, maxtime), Utils(Util), Hook(HookMod) +{ + myhost = host; + this->LinkState = LISTENER; + theirchallenge.clear(); + ourchallenge.clear(); + if (listening && Hook) + InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); +} + +TreeSocket::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, const std::string &ServerName, const std::string &bindto, Module* HookMod) + : InspSocket(SI, host, port, listening, maxtime, bindto), Utils(Util), Hook(HookMod) +{ + myhost = ServerName; + theirchallenge.clear(); + ourchallenge.clear(); + this->LinkState = CONNECTING; + if (Hook) + InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); +} + +/** 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::TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip, Module* HookMod) + : InspSocket(SI, newfd, ip), Utils(Util), Hook(HookMod) +{ + this->LinkState = WAIT_AUTH_1; + theirchallenge.clear(); + ourchallenge.clear(); + sentcapab = false; + /* If we have a transport module hooked to the parent, hook the same module to this + * socket, and set a timer waiting for handshake before we send CAPAB etc. + */ + if (Hook) + InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); + + Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils, 1)); +} + +ServerState TreeSocket::GetLinkState() +{ + return this->LinkState; +} + +Module* TreeSocket::GetHook() +{ + return this->Hook; +} + +TreeSocket::~TreeSocket() +{ + if (Hook) + InspSocketUnhookRequest(this, (Module*)Utils->Creator, Hook).Send(); + + Utils->DelBurstingServer(this); +} + +const std::string& TreeSocket::GetOurChallenge() +{ + return this->ourchallenge; +} + +void TreeSocket::SetOurChallenge(const std::string &c) +{ + this->ourchallenge = c; +} + +const std::string& TreeSocket::GetTheirChallenge() +{ + return this->theirchallenge; +} + +void TreeSocket::SetTheirChallenge(const std::string &c) +{ + this->theirchallenge = c; +} + +std::string TreeSocket::MakePass(const std::string &password, const std::string &challenge) +{ + /* This is a simple (maybe a bit hacky?) HMAC algorithm, thanks to jilles for + * suggesting the use of HMAC to secure the password against various attacks. + * + * Note: If m_sha256.so is not loaded, we MUST fall back to plaintext with no + * HMAC challenge/response. + */ + Module* sha256 = Instance->FindModule("m_sha256.so"); + if (Utils->ChallengeResponse && sha256 && !challenge.empty()) + { + /* XXX: This is how HMAC is supposed to be done: + * + * sha256( (pass xor 0x5c) + sha256((pass xor 0x36) + m) ) + * + * Note that we are encoding the hex hash, not the binary + * output of the hash which is slightly different to standard. + * + * Don't ask me why its always 0x5c and 0x36... it just is. + */ + std::string hmac1, hmac2; + + for (size_t n = 0; n < password.length(); n++) + { + hmac1 += static_cast(password[n] ^ 0x5C); + hmac2 += static_cast(password[n] ^ 0x36); + } + + hmac2 += challenge; + HashResetRequest(Utils->Creator, sha256).Send(); + hmac2 = HashSumRequest(Utils->Creator, sha256, hmac2).Send(); + + HashResetRequest(Utils->Creator, sha256).Send(); + std::string hmac = hmac1 + hmac2; + hmac = HashSumRequest(Utils->Creator, sha256, hmac).Send(); + + return "HMAC-SHA256:"+ hmac; + } + else if (!challenge.empty() && !sha256) + Instance->Log(DEFAULT,"Not authenticating to server using SHA256/HMAC because we don't have m_sha256 loaded!"); + + return password; +} + +/** 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 + * will then send back its own server string. + */ +bool TreeSocket::OnConnected() +{ + if (this->LinkState == CONNECTING) + { + /* we do not need to change state here. */ + 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())+"] started."); + if (Hook) + { + InspSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send(); + this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] using transport \2"+x->Hook+"\2"); + } + this->OutboundPass = x->SendPass; + sentcapab = false; + + /* found who we're supposed to be connecting to, send the neccessary gubbins. */ + if (this->GetHook()) + Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(*x), this->Utils, 1)); + else + this->SendCapabilities(); + + return true; + } + } + } + /* There is a (remote) chance that between the /CONNECT and the connection + * being accepted, some muppet has removed the block and rehashed. + * If that happens the connection hangs here until it's closed. Unlikely + * and rather harmless. + */ + this->Instance->SNO->WriteToSnoMask('l',"Connection to \2"+myhost+"\2 lost link tag(!)"); + return true; +} + +void TreeSocket::OnError(InspSocketError e) +{ + Link* MyLink; + + switch (e) + { + case I_ERR_CONNECT: + this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused"); + MyLink = Utils->FindLink(myhost); + if (MyLink) + Utils->DoFailOver(MyLink); + break; + case I_ERR_SOCKET: + this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Could not create socket"); + break; + case I_ERR_BIND: + this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Error binding socket to address or port"); + break; + case I_ERR_WRITE: + this->Instance->SNO->WriteToSnoMask('l',"Connection failed: I/O error on connection"); + break; + case I_ERR_NOMOREFDS: + this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Operating system is out of file descriptors!"); + break; + default: + if ((errno) && (errno != EINPROGRESS) && (errno != EAGAIN)) + { + std::string errstr = strerror(errno); + this->Instance->SNO->WriteToSnoMask('l',"Connection to \002"+myhost+"\002 failed with OS error: " + errstr); + } + break; + } +} + +int TreeSocket::OnDisconnect() +{ + /* For the same reason as above, we don't + * handle OnDisconnect() + */ + return true; +} + +/** 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 + * end, our connection may be terminated. The hopcounts given + * by this function are relative, this doesn't matter so long as + * they are all >1, as all the remote servers re-calculate them + * to be relative too, with themselves as hop 0. + */ +void TreeSocket::SendServers(TreeServer* Current, TreeServer* s, int hops) +{ + char command[1024]; + for (unsigned int q = 0; q < Current->ChildCount(); q++) + { + TreeServer* recursive_server = Current->GetChild(q); + if (recursive_server != s) + { + snprintf(command,1024,":%s SERVER %s * %d :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops,recursive_server->GetDesc().c_str()); + this->WriteLine(command); + this->WriteLine(":"+recursive_server->GetName()+" VERSION :"+recursive_server->GetVersion()); + /* down to next level */ + this->SendServers(recursive_server, s, hops+1); + } + } +} + +std::string TreeSocket::MyCapabilities() +{ + std::vector modlist; + std::string capabilities; + for (int i = 0; i <= this->Instance->GetModuleCount(); i++) + { + if (this->Instance->modules[i]->GetVersion().Flags & VF_COMMON) + modlist.push_back(this->Instance->Config->module_names[i]); + } + sort(modlist.begin(),modlist.end()); + for (unsigned int i = 0; i < modlist.size(); i++) + { + if (i) + capabilities = capabilities + ","; + capabilities = capabilities + modlist[i]; + } + return capabilities; +} + +std::string TreeSocket::RandString(unsigned int length) +{ + char* randombuf = new char[length+1]; + std::string out; +#ifdef WINDOWS + int fd = -1; +#else + int fd = open("/dev/urandom", O_RDONLY, 0); +#endif + + if (fd >= 0) + { +#ifndef WINDOWS + read(fd, randombuf, length); + close(fd); +#endif + } + else + { + for (unsigned int i = 0; i < length; i++) + randombuf[i] = rand(); + } + + for (unsigned int i = 0; i < length; i++) + { + char randchar = static_cast((randombuf[i] & 0x7F) | 0x21); + out += (randchar == '=' ? '_' : randchar); + } + + delete[] randombuf; + return out; +} + +void TreeSocket::SendCapabilities() +{ + if (sentcapab) + return; + + sentcapab = true; + irc::commasepstream modulelist(MyCapabilities()); + this->WriteLine("CAPAB START"); + + /* Send module names, split at 509 length */ + std::string item = "*"; + std::string line = "CAPAB MODULES "; + while ((item = modulelist.GetToken()) != "") + { + if (line.length() + item.length() + 1 > 509) + { + this->WriteLine(line); + line = "CAPAB MODULES "; + } + + if (line != "CAPAB MODULES ") + line.append(","); + + line.append(item); + } + if (line != "CAPAB MODULES ") + this->WriteLine(line); + + int ip6 = 0; + int ip6support = 0; +#ifdef IPV6 + ip6 = 1; +#endif +#ifdef SUPPORT_IP6LINKS + ip6support = 1; +#endif + std::string extra; + /* Do we have sha256 available? If so, we send a challenge */ + if (Utils->ChallengeResponse && (Instance->FindModule("m_sha256.so"))) + { + this->SetOurChallenge(RandString(20)); + extra = " CHALLENGE=" + this->GetOurChallenge(); + } + + this->WriteLine("CAPAB CAPABILITIES :NICKMAX="+ConvToStr(NICKMAX)+" HALFOP="+ConvToStr(this->Instance->Config->AllowHalfop)+" CHANMAX="+ConvToStr(CHANMAX)+" MAXMODES="+ConvToStr(MAXMODES)+" IDENTMAX="+ConvToStr(IDENTMAX)+" MAXQUIT="+ConvToStr(MAXQUIT)+" MAXTOPIC="+ConvToStr(MAXTOPIC)+" MAXKICK="+ConvToStr(MAXKICK)+" MAXGECOS="+ConvToStr(MAXGECOS)+" MAXAWAY="+ConvToStr(MAXAWAY)+" IP6NATIVE="+ConvToStr(ip6)+" IP6SUPPORT="+ConvToStr(ip6support)+" PROTOCOL="+ConvToStr(ProtocolVersion)+extra+" PREFIX="+Instance->Modes->BuildPrefixes()+" CHANMODES="+Instance->Modes->ChanModes()); + + this->WriteLine("CAPAB END"); +} + +/* Check a comma seperated list for an item */ +bool TreeSocket::HasItem(const std::string &list, const std::string &item) +{ + irc::commasepstream seplist(list); + std::string item2 = "*"; + while ((item2 = seplist.GetToken()) != "") + { + if (item2 == item) + return true; + } + return false; +} + +/* Isolate and return the elements that are different between two comma seperated lists */ +std::string TreeSocket::ListDifference(const std::string &one, const std::string &two) +{ + irc::commasepstream list_one(one); + std::string item = "*"; + std::string result; + while ((item = list_one.GetToken()) != "") + { + if (!HasItem(two, item)) + { + result.append(" "); + result.append(item); + } + } + return result; +} + +void TreeSocket::SendError(const std::string &errormessage) +{ + /* Display the error locally as well as sending it remotely */ + this->WriteLine("ERROR :"+errormessage); + this->Instance->SNO->WriteToSnoMask('l',"Sent \2ERROR\2 to "+this->InboundServerName+": "+errormessage); + /* One last attempt to make sure the error reaches its target */ + this->FlushWriteBuffer(); +} + +bool TreeSocket::Capab(const std::deque ¶ms) +{ + if (params.size() < 1) + { + this->SendError("Invalid number of parameters for CAPAB - Mismatched version"); + return false; + } + if (params[0] == "START") + { + this->ModuleList.clear(); + this->CapKeys.clear(); + } + else if (params[0] == "END") + { + std::string reason; + int ip6support = 0; +#ifdef SUPPORT_IP6LINKS + ip6support = 1; +#endif + /* Compare ModuleList and check CapKeys... + * Maybe this could be tidier? -- Brain + */ + if ((this->ModuleList != this->MyCapabilities()) && (this->ModuleList.length())) + { + std::string diff = ListDifference(this->ModuleList, this->MyCapabilities()); + if (!diff.length()) + { + diff = "your server:" + ListDifference(this->MyCapabilities(), this->ModuleList); + } + else + { + diff = "this server:" + diff; + } + if (diff.length() == 12) + reason = "Module list in CAPAB is not alphabetically ordered, cannot compare lists."; + else + reason = "Modules loaded on these servers are not correctly matched, these modules are not loaded on " + diff; + } + + cap_validation valid_capab[] = { + {"Maximum nickname lengths differ or remote nickname length not specified", "NICKMAX", NICKMAX}, + {"Maximum ident lengths differ or remote ident length not specified", "IDENTMAX", IDENTMAX}, + {"Maximum channel lengths differ or remote channel length not specified", "CHANMAX", CHANMAX}, + {"Maximum modes per line differ or remote modes per line not specified", "MAXMODES", MAXMODES}, + {"Maximum quit lengths differ or remote quit length not specified", "MAXQUIT", MAXQUIT}, + {"Maximum topic lengths differ or remote topic length not specified", "MAXTOPIC", MAXTOPIC}, + {"Maximum kick lengths differ or remote kick length not specified", "MAXKICK", MAXKICK}, + {"Maximum GECOS (fullname) lengths differ or remote GECOS length not specified", "MAXGECOS", MAXGECOS}, + {"Maximum awaymessage lengths differ or remote awaymessage length not specified", "MAXAWAY", MAXAWAY}, + {"", "", 0} + }; + + if (((this->CapKeys.find("IP6SUPPORT") == this->CapKeys.end()) && (ip6support)) || ((this->CapKeys.find("IP6SUPPORT") != this->CapKeys.end()) && (this->CapKeys.find("IP6SUPPORT")->second != ConvToStr(ip6support)))) + reason = "We don't both support linking to IPV6 servers"; + if (((this->CapKeys.find("IP6NATIVE") != this->CapKeys.end()) && (this->CapKeys.find("IP6NATIVE")->second == "1")) && (!ip6support)) + reason = "The remote server is IPV6 native, and we don't support linking to IPV6 servers"; + if (((this->CapKeys.find("PROTOCOL") == this->CapKeys.end()) || ((this->CapKeys.find("PROTOCOL") != this->CapKeys.end()) && (this->CapKeys.find("PROTOCOL")->second != ConvToStr(ProtocolVersion))))) + { + if (this->CapKeys.find("PROTOCOL") != this->CapKeys.end()) + reason = "Mismatched protocol versions "+this->CapKeys.find("PROTOCOL")->second+" and "+ConvToStr(ProtocolVersion); + else + reason = "Protocol version not specified"; + } + + if(this->CapKeys.find("PREFIX") != this->CapKeys.end() && this->CapKeys.find("PREFIX")->second != this->Instance->Modes->BuildPrefixes()) + reason = "One or more of the prefixes on the remote server are invalid on this server."; + + if (((this->CapKeys.find("HALFOP") == this->CapKeys.end()) && (Instance->Config->AllowHalfop)) || ((this->CapKeys.find("HALFOP") != this->CapKeys.end()) && (this->CapKeys.find("HALFOP")->second != ConvToStr(Instance->Config->AllowHalfop)))) + reason = "We don't both have halfop support enabled/disabled identically"; + + for (int x = 0; valid_capab[x].size; ++x) + { + if (((this->CapKeys.find(valid_capab[x].key) == this->CapKeys.end()) || ((this->CapKeys.find(valid_capab[x].key) != this->CapKeys.end()) && + (this->CapKeys.find(valid_capab[x].key)->second != ConvToStr(valid_capab[x].size))))) + reason = valid_capab[x].reason; + } + + /* Challenge response, store their challenge for our password */ + std::map::iterator n = this->CapKeys.find("CHALLENGE"); + if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->FindModule("m_sha256.so"))) + { + /* Challenge-response is on now */ + this->SetTheirChallenge(n->second); + if (!this->GetTheirChallenge().empty() && (this->LinkState == CONNECTING)) + { + this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc); + } + } + else + { + /* They didnt specify a challenge or we don't have m_sha256.so, we use plaintext */ + if (this->LinkState == CONNECTING) + this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+OutboundPass+" 0 :"+this->Instance->Config->ServerDesc); + } + + if (reason.length()) + { + this->SendError("CAPAB negotiation failed: "+reason); + return false; + } + } + else if ((params[0] == "MODULES") && (params.size() == 2)) + { + if (!this->ModuleList.length()) + { + this->ModuleList.append(params[1]); + } + else + { + this->ModuleList.append(","); + this->ModuleList.append(params[1]); + } + } + + else if ((params[0] == "CAPABILITIES") && (params.size() == 2)) + { + irc::tokenstream capabs(params[1]); + std::string item; + bool more = true; + while ((more = capabs.GetToken(item))) + { + /* Process each key/value pair */ + std::string::size_type equals = item.rfind('='); + if (equals != std::string::npos) + { + std::string var = item.substr(0, equals); + std::string value = item.substr(equals+1, item.length()); + CapKeys[var] = value; + } + } + } + return true; +} + +/** 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 + * too many times a month ;-) + */ +void TreeSocket::SquitServer(std::string &from, TreeServer* Current) +{ + /* recursively squit the servers attached to 'Current'. + * We're going backwards so we don't remove users + * while we still need them ;) + */ + for (unsigned int q = 0; q < Current->ChildCount(); q++) + { + TreeServer* recursive_server = Current->GetChild(q); + this->SquitServer(from,recursive_server); + } + /* Now we've whacked the kids, whack self */ + num_lost_servers++; + num_lost_users += Current->QuitUsers(from); +} + +/** This is a wrapper function for SquitServer above, which + * does some validation first and passes on the SQUIT to all + * other remaining servers. + */ +void TreeSocket::Squit(TreeServer* Current, const std::string &reason) +{ + if ((Current) && (Current != Utils->TreeRoot)) + { + Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server"); + rmode.Send(Instance); + + std::deque params; + params.push_back(Current->GetName()); + params.push_back(":"+reason); + Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName()); + if (Current->GetParent() == Utils->TreeRoot) + { + this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split: "+reason); + } + else + { + this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason); + } + num_lost_servers = 0; + num_lost_users = 0; + std::string from = Current->GetParent()->GetName()+" "+Current->GetName(); + SquitServer(from, Current); + Current->Tidy(); + Current->GetParent()->DelChild(Current); + DELETE(Current); + this->Instance->SNO->WriteToSnoMask('l',"Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers); + } + else + Instance->Log(DEFAULT,"Squit from unknown server"); +} + +/** FMODE command - server mode with timestamp checks */ +bool TreeSocket::ForceMode(const std::string &source, std::deque ¶ms) +{ + /* Chances are this is a 1.0 FMODE without TS */ + if (params.size() < 3) + { + /* No modes were in the command, probably a channel with no modes set on it */ + return true; + } + + bool smode = false; + std::string sourceserv; + /* Are we dealing with an FMODE from a user, or from a server? */ + userrec* who = this->Instance->FindNick(source); + if (who) + { + /* FMODE from a user, set sourceserv to the users server name */ + sourceserv = who->server; + } + else + { + /* FMODE from a server, create a fake user to receive mode feedback */ + who = new userrec(this->Instance); + who->SetFd(FD_MAGIC_NUMBER); + smode = true; /* Setting this flag tells us we should free the userrec later */ + sourceserv = source; /* Set sourceserv to the actual source string */ + } + const char* modelist[64]; + time_t TS = 0; + int n = 0; + memset(&modelist,0,sizeof(modelist)); + for (unsigned int q = 0; (q < params.size()) && (q < 64); q++) + { + if (q == 1) + { + /* The timestamp is in this position. + * We don't want to pass that up to the + * server->client protocol! + */ + TS = atoi(params[q].c_str()); + } + else + { + /* Everything else is fine to append to the modelist */ + modelist[n++] = params[q].c_str(); + } + + } + /* Extract the TS value of the object, either userrec or chanrec */ + userrec* dst = this->Instance->FindNick(params[0]); + chanrec* chan = NULL; + time_t ourTS = 0; + if (dst) + { + ourTS = dst->age; + } + else + { + chan = this->Instance->FindChan(params[0]); + if (chan) + { + ourTS = chan->age; + } + else + /* Oops, channel doesnt exist! */ + return true; + } + + if (!TS) + { + Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FMODE. Are some services authors smoking craq, or is it 1970 again?. Dropped."); + Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FMODE with a TS of zero. Total craq. Mode was dropped.", sourceserv.c_str()); + return true; + } + + /* TS is equal or less: Merge the mode changes into ours and pass on. + */ + if (TS <= ourTS) + { + if ((TS < ourTS) && (!dst)) + Instance->Log(DEFAULT,"*** BUG *** Channel TS sent in FMODE to %s is %lu which is not equal to %lu!", params[0].c_str(), TS, ourTS); + + if (smode) + { + this->Instance->SendMode(modelist, n, who); + } + else + { + this->Instance->CallCommandHandler("MODE", modelist, n, who); + } + /* HOT POTATO! PASS IT ON! */ + Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv); + } + /* If the TS is greater than ours, we drop the mode and dont pass it anywhere. + */ + + if (smode) + DELETE(who); + + return true; +} + +/** FTOPIC command */ +bool TreeSocket::ForceTopic(const std::string &source, std::deque ¶ms) +{ + if (params.size() != 4) + return true; + time_t ts = atoi(params[1].c_str()); + std::string nsource = source; + chanrec* c = this->Instance->FindChan(params[0]); + if (c) + { + if ((ts >= c->topicset) || (!*c->topic)) + { + std::string oldtopic = c->topic; + strlcpy(c->topic,params[3].c_str(),MAXTOPIC); + strlcpy(c->setby,params[2].c_str(),127); + c->topicset = ts; + /* if the topic text is the same as the current topic, + * dont bother to send the TOPIC command out, just silently + * update the set time and set nick. + */ + if (oldtopic != params[3]) + { + userrec* user = this->Instance->FindNick(source); + if (!user) + { + c->WriteChannelWithServ(Instance->Config->ServerName, "TOPIC %s :%s", c->name, c->topic); + } + else + { + c->WriteChannel(user, "TOPIC %s :%s", c->name, c->topic); + nsource = user->server; + } + /* all done, send it on its way */ + params[3] = ":" + params[3]; + Utils->DoOneToAllButSender(source,"FTOPIC",params,nsource); + } + } + + } + return true; +} + +/** FJOIN, similar to TS6 SJOIN, but not quite. */ +bool TreeSocket::ForceJoin(const 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 of its + * modes from the channel, before introducing new users into the channel + * which are listed in the FJOIN command's parameters. 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 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; + + irc::modestacker modestack(true); /* Modes to apply from the users in the user list */ + 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 */ + irc::tokenstream users(params[2]); /* Users from the user list */ + bool apply_other_sides_modes = true; /* True if we are accepting the other side's modes */ + chanrec* chan = this->Instance->FindChan(channel); /* The channel we're sending joins to */ + time_t ourTS = chan ? chan->age : Instance->Time(true)+600; /* The TS of our side of the link */ + bool created = !chan; /* True if the channel doesnt exist here yet */ + std::string item; /* One item in the list of nicks */ + + params[2] = ":" + params[2]; + Utils->DoOneToAllButSender(source,"FJOIN",params,source); + + if (!TS) + { + Instance->Log(DEFAULT,"*** BUG? *** TS of 0 sent to FJOIN. Are some services authors smoking craq, or is it 1970 again?. Dropped."); + Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FJOIN with a TS of zero. Total craq. Command was dropped.", source.c_str()); + return true; + } + + /* If our TS is less than theirs, we dont accept their modes */ + if (ourTS < TS) + apply_other_sides_modes = false; + + /* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */ + if (ourTS > TS) + { + std::deque param_list; + if (Utils->AnnounceTSChange && chan) + chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS); + ourTS = TS; + if (!created) + { + chan->age = TS; + param_list.push_back(channel); + this->RemoveStatus(Instance->Config->ServerName, param_list); + } + } + + /* Now, process every 'prefixes,nick' pair */ + while (users.GetToken(item)) + { + const char* usr = item.c_str(); + if (usr && *usr) + { + const char* permissions = usr; + /* Iterate through all the prefix values, convert them from prefixes to mode letters */ + std::string modes; + while ((*permissions) && (*permissions != ',')) + { + ModeHandler* mh = Instance->Modes->FindPrefix(*permissions); + if (mh) + modes = modes + mh->GetModeChar(); + else + { + this->SendError(std::string("Invalid prefix '")+(*permissions)+"' in FJOIN"); + return false; + } + usr++; + permissions++; + } + /* Advance past the comma, to the nick */ + usr++; + + /* Check the user actually exists */ + who = this->Instance->FindNick(usr); + if (who) + { + /* Check that the user's 'direction' is correct */ + TreeServer* route_back_again = Utils->BestRouteTo(who->server); + if ((!route_back_again) || (route_back_again->GetSocket() != this)) + continue; + + /* Add any permissions this user had to the mode stack */ + for (std::string::iterator x = modes.begin(); x != modes.end(); ++x) + modestack.Push(*x, who->nick); + + chanrec::JoinUser(this->Instance, who, channel.c_str(), true, "", TS); + } + else + { + Instance->Log(SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", usr, channel.c_str()); + continue; + } + } + } + + /* Flush mode stacker if we lost the FJOIN or had equal TS */ + if (apply_other_sides_modes) + { + std::deque stackresult; + const char* mode_junk[MAXMODES+2]; + userrec* n = new userrec(Instance); + n->SetFd(FD_MAGIC_NUMBER); + mode_junk[0] = channel.c_str(); + + while (modestack.GetStackedLine(stackresult)) + { + for (size_t j = 0; j < stackresult.size(); j++) + { + mode_junk[j+1] = stackresult[j].c_str(); + } + Instance->SendMode(mode_junk, stackresult.size() + 1, n); + } + + delete n; + } + + return true; +} + +/** NICK command */ +bool TreeSocket::IntroduceClient(const std::string &source, std::deque ¶ms) +{ + /** Do we have enough parameters: + * NICK age nick host dhost ident +modes ip :gecos + */ + if (params.size() != 8) + { + this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)"); + return true; + } + + time_t age = ConvToInt(params[0]); + const char* tempnick = params[1].c_str(); + + cmd_validation valid[] = { {"Nickname", 1, NICKMAX}, {"Hostname", 2, 64}, {"Displayed hostname", 3, 64}, {"Ident", 4, IDENTMAX}, {"GECOS", 7, MAXGECOS}, {"", 0, 0} }; + + TreeServer* remoteserver = Utils->FindServer(source); + if (!remoteserver) + { + this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Unknown server "+source+")"); + return true; + } + + /* Check parameters for validity before introducing the client, discovered by dmb */ + if (!age) + { + this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (Invalid TS?)"); + return true; + } + for (size_t x = 0; valid[x].length; ++x) + { + if (params[valid[x].param].length() > valid[x].length) + { + this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+params[1]+" :Invalid client introduction (" + valid[x].item + " > " + ConvToStr(valid[x].length) + ")"); + return true; + } + } + + /** Our client looks ok, lets introduce it now + */ + Instance->Log(DEBUG,"New remote client %s",tempnick); + user_hash::iterator iter = this->Instance->clientlist->find(tempnick); + + if (iter != this->Instance->clientlist->end()) + { + /* nick collision */ + this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" KILL "+tempnick+" :Nickname collision"); + userrec::QuitUser(this->Instance, iter->second, "Nickname collision"); + return true; + } + + userrec* _new = new userrec(this->Instance); + (*(this->Instance->clientlist))[tempnick] = _new; + _new->SetFd(FD_MAGIC_NUMBER); + strlcpy(_new->nick, tempnick,NICKMAX-1); + strlcpy(_new->host, params[2].c_str(),64); + strlcpy(_new->dhost, params[3].c_str(),64); + _new->server = this->Instance->FindServerNamePtr(source.c_str()); + strlcpy(_new->ident, params[4].c_str(),IDENTMAX); + strlcpy(_new->fullname, params[7].c_str(),MAXGECOS); + _new->registered = REG_ALL; + _new->signon = age; + + /* we need to remove the + from the modestring, so we can do our stuff */ + std::string::size_type pos_after_plus = params[5].find_first_not_of('+'); + if (pos_after_plus != std::string::npos) + params[5] = params[5].substr(pos_after_plus); + + for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++) + { + _new->modes[(*v)-65] = 1; + /* For each mode thats set, increase counter */ + ModeHandler* mh = Instance->Modes->FindMode(*v, MODETYPE_USER); + if (mh) + mh->ChangeCount(1); + } + + /* now we've done with modes processing, put the + back for remote servers */ + params[5] = "+" + params[5]; + +#ifdef SUPPORT_IP6LINKS + if (params[6].find_first_of(":") != std::string::npos) + _new->SetSockAddr(AF_INET6, params[6].c_str(), 0); + else +#endif + _new->SetSockAddr(AF_INET, params[6].c_str(), 0); + + Instance->AddGlobalClone(_new); + + bool dosend = !(((this->Utils->quiet_bursts) && (this->bursting || Utils->FindRemoteBurstServer(remoteserver))) || (this->Instance->SilentULine(_new->server))); + + if (dosend) + this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s] [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString(), _new->fullname); + + params[7] = ":" + params[7]; + Utils->DoOneToAllButSender(source,"NICK", params, source); + + // Increment the Source Servers User Count.. + TreeServer* SourceServer = Utils->FindServer(source); + if (SourceServer) + { + SourceServer->AddUserCount(); + } + + FOREACH_MOD_I(Instance,I_OnPostConnect,OnPostConnect(_new)); + + return true; +} + +/** 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. + */ +void TreeSocket::SendFJoins(TreeServer* Current, chanrec* c) +{ + std::string buffer; + char list[MAXBUF]; + std::string individual_halfops = std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age); + + size_t dlen, curlen; + dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age); + int numusers = 0; + char* ptr = list + dlen; + + CUList *ulist = c->GetUsers(); + std::string modes; + std::string params; + + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + { + // The first parameter gets a : before it + size_t ptrlen = snprintf(ptr, MAXBUF, " %s%s,%s", !numusers ? ":" : "", c->GetAllPrefixChars(i->first), i->first->nick); + + curlen += ptrlen; + ptr += ptrlen; + + numusers++; + + if (curlen > (480-NICKMAX)) + { + buffer.append(list).append("\r\n"); + dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age); + ptr = list + dlen; + ptrlen = 0; + numusers = 0; + } + } + + if (numusers) + buffer.append(list).append("\r\n"); + + buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(c->ChanModes(true)).append("\r\n"); + + int linesize = 1; + for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++) + { + int size = strlen(b->data) + 2; + int currsize = linesize + size; + if (currsize <= 350) + { + modes.append("b"); + params.append(" ").append(b->data); + linesize += size; + } + if ((params.length() >= MAXMODES) || (currsize > 350)) + { + /* Wrap at MAXMODES */ + buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params).append("\r\n"); + modes.clear(); + params.clear(); + linesize = 1; + } + } + + /* Only send these if there are any */ + if (!modes.empty()) + buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params); + + this->WriteLine(buffer); +} + +/** Send G, Q, Z and E lines */ +void TreeSocket::SendXLines(TreeServer* Current) +{ + char data[MAXBUF]; + std::string buffer; + std::string n = this->Instance->Config->ServerName; + const char* sn = n.c_str(); + /* 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++) + { + snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + for (std::vector::iterator i = Instance->XLines->qlines.begin(); i != Instance->XLines->qlines.end(); i++) + { + snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + for (std::vector::iterator i = Instance->XLines->glines.begin(); i != Instance->XLines->glines.end(); i++) + { + snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + for (std::vector::iterator i = Instance->XLines->elines.begin(); i != Instance->XLines->elines.end(); i++) + { + snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + for (std::vector::iterator i = Instance->XLines->pzlines.begin(); i != Instance->XLines->pzlines.end(); i++) + { + snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + for (std::vector::iterator i = Instance->XLines->pqlines.begin(); i != Instance->XLines->pqlines.end(); i++) + { + snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + for (std::vector::iterator i = Instance->XLines->pglines.begin(); i != Instance->XLines->pglines.end(); i++) + { + snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + for (std::vector::iterator i = Instance->XLines->pelines.begin(); i != Instance->XLines->pelines.end(); i++) + { + snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason); + buffer.append(data); + } + + if (!buffer.empty()) + this->WriteLine(buffer); +} + +/** Send channel modes and topics */ +void TreeSocket::SendChannelModes(TreeServer* Current) +{ + char data[MAXBUF]; + std::deque list; + std::string n = this->Instance->Config->ServerName; + const char* sn = n.c_str(); + Instance->Log(DEBUG,"Sending channels and modes, %d to send", this->Instance->chanlist->size()); + for (chan_hash::iterator c = this->Instance->chanlist->begin(); c != this->Instance->chanlist->end(); c++) + { + SendFJoins(Current, c->second); + if (*c->second->topic) + { + 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*)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*)Utils->Creator,(void*)this,list[j])); + } + } +} + +/** send all users and their oper state/modes */ +void TreeSocket::SendUsers(TreeServer* Current) +{ + char data[MAXBUF]; + std::deque list; + std::string dataline; + for (user_hash::iterator u = this->Instance->clientlist->begin(); u != this->Instance->clientlist->end(); u++) + { + if (u->second->registered == REG_ALL) + { + snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->FormatModes(),u->second->GetIPString(),u->second->fullname); + this->WriteLine(data); + if (*u->second->oper) + { + snprintf(data,MAXBUF,":%s OPERTYPE %s", u->second->nick, u->second->oper); + this->WriteLine(data); + } + if (*u->second->awaymsg) + { + snprintf(data,MAXBUF,":%s AWAY :%s", u->second->nick, u->second->awaymsg); + this->WriteLine(data); + } + } + } + for (user_hash::iterator u = this->Instance->clientlist->begin(); u != this->Instance->clientlist->end(); u++) + { + 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*)Utils->Creator,(void*)this,list[j])); + } + } +} + +/** 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. + */ +void TreeSocket::DoBurst(TreeServer* s) +{ + std::string name = s->GetName(); + std::string burst = "BURST "+ConvToStr(Instance->Time(true)); + std::string endburst = "ENDBURST"; + this->Instance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s).", name.c_str(), this->GetTheirChallenge().empty() ? "plaintext password" : "SHA256-HMAC challenge-response"); + this->WriteLine(burst); + /* send our version string */ + this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" VERSION :"+this->Instance->GetVersionString()); + /* Send server tree */ + 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*)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 + * 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. + * + * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES + * THE SOCKET OBJECT FOR US. + */ +bool TreeSocket::OnDataReady() +{ + char* data = this->Read(); + /* Check that the data read is a valid pointer and it has some content */ + if (data && *data) + { + this->in_buffer.append(data); + /* While there is at least one new line in the buffer, + * do something useful (we hope!) with it. + */ + while (in_buffer.find("\n") != std::string::npos) + { + std::string ret = in_buffer.substr(0,in_buffer.find("\n")-1); + in_buffer = in_buffer.substr(in_buffer.find("\n")+1,in_buffer.length()-in_buffer.find("\n")); + /* Use rfind here not find, as theres more + * chance of the \r being near the end of the + * string, not the start. + */ + if (ret.find("\r") != std::string::npos) + ret = in_buffer.substr(0,in_buffer.find("\r")-1); + /* Process this one, abort if it + * didnt return true. + */ + if (!this->ProcessLine(ret)) + { + return false; + } + } + return true; + } + /* EAGAIN returns an empty but non-NULL string, so this + * evaluates to TRUE for EAGAIN but to FALSE for EOF. + */ + return (data && !*data); +} + diff --git a/src/modules/m_spanningtree/treesocket2.cpp b/src/modules/m_spanningtree/treesocket2.cpp index d383e2394..f518151e9 100644 --- a/src/modules/m_spanningtree/treesocket2.cpp +++ b/src/modules/m_spanningtree/treesocket2.cpp @@ -1 +1,1554 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "socketengine.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" #include "m_spanningtree/resolvers.h" #include "m_spanningtree/handshaketimer.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ static std::map warned; /* Server names that have had protocol violation warnings displayed for them */ int TreeSocket::WriteLine(std::string line) { Instance->Log(DEBUG, "S[%d] -> %s", this->GetFd(), line.c_str()); line.append("\r\n"); return this->Write(line); } /* Handle ERROR command */ bool TreeSocket::Error(std::deque ¶ms) { if (params.size() < 1) return false; this->Instance->SNO->WriteToSnoMask('l',"ERROR from %s: %s",(!InboundServerName.empty() ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str()); /* we will return false to cause the socket to close. */ return false; } bool TreeSocket::Modules(const std::string &prefix, std::deque ¶ms) { if (params.empty()) return true; if (!this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) { /* Pass it on, not for us */ Utils->DoOneToOne(prefix, "MODULES", params, params[0]); return true; } char strbuf[MAXBUF]; std::deque par; par.push_back(prefix); par.push_back(""); userrec* source = this->Instance->FindNick(prefix); if (!source) return true; for (unsigned int i = 0; i < Instance->Config->module_names.size(); i++) { Version V = Instance->modules[i]->GetVersion(); char modulename[MAXBUF]; char flagstate[MAXBUF]; *flagstate = 0; if (V.Flags & VF_STATIC) strlcat(flagstate,", static",MAXBUF); if (V.Flags & VF_VENDOR) strlcat(flagstate,", vendor",MAXBUF); if (V.Flags & VF_COMMON) strlcat(flagstate,", common",MAXBUF); if (V.Flags & VF_SERVICEPROVIDER) strlcat(flagstate,", service provider",MAXBUF); if (!flagstate[0]) strcpy(flagstate," "); strlcpy(modulename,Instance->Config->module_names[i].c_str(),256); if (*source->oper) { snprintf(strbuf, MAXBUF, "::%s 900 %s :0x%08lx %d.%d.%d.%d %s (%s)",Instance->Config->ServerName,source->nick,(long unsigned int)Instance->modules[i],V.Major,V.Minor,V.Revision,V.Build,ServerConfig::CleanFilename(modulename),flagstate+2); } else { snprintf(strbuf, MAXBUF, "::%s 900 %s :%s",Instance->Config->ServerName,source->nick,ServerConfig::CleanFilename(modulename)); } par[1] = strbuf; Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server); } snprintf(strbuf, MAXBUF, "::%s 901 %s :End of MODULES list", Instance->Config->ServerName, source->nick); par[1] = strbuf; Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server); return true; } /** remote MOTD. leet, huh? */ bool TreeSocket::Motd(const std::string &prefix, std::deque ¶ms) { if (params.size() > 0) { if (this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) { /* It's for our server */ string_list results; userrec* source = this->Instance->FindNick(prefix); if (source) { std::deque par; par.push_back(prefix); par.push_back(""); if (!Instance->Config->MOTD.size()) { par[1] = std::string("::")+Instance->Config->ServerName+" 422 "+source->nick+" :Message of the day file is missing."; 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"; 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]; 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."; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } else { /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) Utils->DoOneToOne(prefix, "MOTD", params, params[0]); } } return true; } /** remote ADMIN. leet, huh? */ bool TreeSocket::Admin(const std::string &prefix, std::deque ¶ms) { if (params.size() > 0) { if (this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) { /* It's for our server */ string_list results; userrec* source = this->Instance->FindNick(prefix); if (source) { std::deque par; par.push_back(prefix); par.push_back(""); par[1] = std::string("::")+Instance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+Instance->Config->ServerName; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 257 "+source->nick+" :Name - "+Instance->Config->AdminName; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :Nickname - "+Instance->Config->AdminNick; 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; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } else { /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) Utils->DoOneToOne(prefix, "ADMIN", params, params[0]); } } return true; } bool TreeSocket::Stats(const std::string &prefix, std::deque ¶ms) { /* Get the reply to a STATS query if it matches this servername, * and send it back as a load of PUSH queries */ if (params.size() > 1) { if (this->Instance->MatchText(this->Instance->Config->ServerName, params[1])) { /* It's for our server */ string_list results; userrec* source = this->Instance->FindNick(prefix); if (source) { std::deque par; par.push_back(prefix); par.push_back(""); DoStats(this->Instance, *(params[0].c_str()), source, results); for (size_t i = 0; i < results.size(); i++) { par[1] = "::" + results[i]; Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); } } } else { /* Pass it on */ userrec* source = this->Instance->FindNick(prefix); if (source) Utils->DoOneToOne(prefix, "STATS", params, params[1]); } } return true; } /** Because the core won't let users or even SERVERS set +o, * we use the OPERTYPE command to do this. */ bool TreeSocket::OperType(const std::string &prefix, std::deque ¶ms) { if (params.size() != 1) return true; std::string opertype = params[0]; userrec* u = this->Instance->FindNick(prefix); if (u) { u->modes[UM_OPERATOR] = 1; this->Instance->all_opers.push_back(u); strlcpy(u->oper,opertype.c_str(),NICKMAX-1); Utils->DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server); this->Instance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick,u->ident,u->host,irc::Spacify(opertype.c_str())); } return true; } /** Because Andy insists that services-compatible servers must * implement SVSNICK and SVSJOIN, that's exactly what we do :p */ bool TreeSocket::ForceNick(const std::string &prefix, std::deque ¶ms) { if (params.size() < 3) return true; userrec* u = this->Instance->FindNick(params[0]); if (u) { Utils->DoOneToAllButSender(prefix,"SVSNICK",params,prefix); if (IS_LOCAL(u)) { std::deque par; par.push_back(params[1]); if (!u->ForceNickChange(params[1].c_str())) { userrec::QuitUser(this->Instance, u, "Nickname collision"); return true; } u->age = atoi(params[2].c_str()); } } return true; } bool TreeSocket::OperQuit(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; userrec* u = this->Instance->FindNick(prefix); if (u) { u->SetOperQuit(params[0]); params[0] = ":" + params[0]; Utils->DoOneToAllButSender(prefix,"OPERQUIT",params,prefix); } return true; } bool TreeSocket::ServiceJoin(const std::string &prefix, std::deque ¶ms) { if (params.size() < 2) return true; userrec* u = this->Instance->FindNick(params[0]); if (u) { /* only join if it's local, otherwise just pass it on! */ if (IS_LOCAL(u)) chanrec::JoinUser(this->Instance, u, params[1].c_str(), false, "", Instance->Time()); Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix); } return true; } bool TreeSocket::RemoteRehash(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return false; std::string servermask = params[0]; if (this->Instance->MatchText(this->Instance->Config->ServerName,servermask)) { this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated by \002"+prefix+"\002."); this->Instance->RehashServer(); Utils->ReadConfiguration(false); InitializeDisabledCommands(Instance->Config->DisabledCommands, Instance); } Utils->DoOneToAllButSender(prefix,"REHASH",params,prefix); return true; } bool TreeSocket::RemoteKill(const std::string &prefix, std::deque ¶ms) { if (params.size() != 2) return true; userrec* who = this->Instance->FindNick(params[0]); if (who) { /* Prepend kill source, if we don't have one */ if (*(params[1].c_str()) != '[') { params[1] = "[" + prefix + "] Killed (" + params[1] +")"; } std::string reason = params[1]; params[1] = ":" + params[1]; Utils->DoOneToAllButSender(prefix,"KILL",params,prefix); // NOTE: This is safe with kill hiding on, as RemoteKill is only reached if we have a server prefix. // in short this is not executed for USERS. who->Write(":%s KILL %s :%s (%s)", prefix.c_str(), who->nick, prefix.c_str(), reason.c_str()); userrec::QuitUser(this->Instance,who,reason); } return true; } bool TreeSocket::LocalPong(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; if (params.size() == 1) { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { ServerSource->SetPingFlag(); ServerSource->rtt = Instance->Time() - ServerSource->LastPing; } } else { std::string forwardto = params[1]; if (forwardto == this->Instance->Config->ServerName) { /* * this is a PONG for us * if the prefix is a user, check theyre local, and if they are, * dump the PONG reply back to their fd. If its a server, do nowt. * Services might want to send these s->s, but we dont need to yet. */ userrec* u = this->Instance->FindNick(prefix); if (u) { u->WriteServ("PONG %s %s",params[0].c_str(),params[1].c_str()); } } else { // not for us, pass it on :) Utils->DoOneToOne(prefix,"PONG",params,forwardto); } } return true; } bool TreeSocket::MetaData(const std::string &prefix, std::deque ¶ms) { if (params.size() < 2) return true; else if (params.size() < 3) params.push_back(""); TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { Utils->SetRemoteBursting(ServerSource, false); if (params[0] == "*") { FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_OTHER,NULL,params[1],params[2])); } else if (*(params[0].c_str()) == '#') { chanrec* c = this->Instance->FindChan(params[0]); if (c) { FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2])); } } else if (*(params[0].c_str()) != '#') { userrec* u = this->Instance->FindNick(params[0]); if (u) { FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2])); } } } params[2] = ":" + params[2]; Utils->DoOneToAllButSender(prefix,"METADATA",params,prefix); return true; } bool TreeSocket::ServerVersion(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) { ServerSource->SetVersion(params[0]); } params[0] = ":" + params[0]; Utils->DoOneToAllButSender(prefix,"VERSION",params,prefix); return true; } bool TreeSocket::ChangeHost(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; userrec* u = this->Instance->FindNick(prefix); if (u) { u->ChangeDisplayedHost(params[0].c_str()); Utils->DoOneToAllButSender(prefix,"FHOST",params,u->server); } return true; } bool TreeSocket::AddLine(const std::string &prefix, std::deque ¶ms) { if (params.size() < 6) return true; bool propogate = false; if (!this->bursting) Utils->lines_to_apply = 0; switch (*(params[0].c_str())) { case 'Z': propogate = Instance->XLines->add_zline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->zline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); if (propogate) Utils->lines_to_apply |= APPLY_ZLINES; break; case 'Q': propogate = Instance->XLines->add_qline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->qline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); if (propogate) Utils->lines_to_apply |= APPLY_QLINES; break; case 'E': propogate = Instance->XLines->add_eline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->eline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); break; case 'G': propogate = Instance->XLines->add_gline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); Instance->XLines->gline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); if (propogate) Utils->lines_to_apply |= APPLY_GLINES; break; case 'K': propogate = Instance->XLines->add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); if (propogate) Utils->lines_to_apply |= APPLY_KLINES; break; default: /* Just in case... */ this->Instance->SNO->WriteToSnoMask('x',"\2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!"); propogate = false; break; } /* Send it on its way */ if (propogate) { if (atoi(params[4].c_str())) { time_t c_requires_crap = ConvToInt(params[4]) + Instance->Time(); this->Instance->SNO->WriteToSnoMask('x',"%s Added %cLINE on %s to expire on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),Instance->TimeString(c_requires_crap).c_str(),params[5].c_str()); } else { 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]; Utils->DoOneToAllButSender(prefix,"ADDLINE",params,prefix); } if (!this->bursting) { Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; } return true; } bool TreeSocket::ChangeName(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; userrec* u = this->Instance->FindNick(prefix); if (u) { u->ChangeName(params[0].c_str()); params[0] = ":" + params[0]; Utils->DoOneToAllButSender(prefix,"FNAME",params,u->server); } return true; } bool TreeSocket::Whois(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; userrec* u = this->Instance->FindNick(prefix); if (u) { // an incoming request if (params.size() == 1) { userrec* x = this->Instance->FindNick(params[0]); if ((x) && (IS_LOCAL(x))) { userrec* x = this->Instance->FindNick(params[0]); char signon[MAXBUF]; char idle[MAXBUF]; snprintf(signon, MAXBUF, "%lu", (unsigned long)x->signon); snprintf(idle, MAXBUF, "%lu", (unsigned long)abs((x->idle_lastmsg) - Instance->Time(true))); std::deque par; par.push_back(prefix); par.push_back(signon); par.push_back(idle); // ours, we're done, pass it BACK Utils->DoOneToOne(params[0], "IDLE", par, u->server); } else { // not ours pass it on if (x) Utils->DoOneToOne(prefix, "IDLE", params, x->server); } } else if (params.size() == 3) { std::string who_did_the_whois = params[0]; userrec* who_to_send_to = this->Instance->FindNick(who_did_the_whois); if ((who_to_send_to) && (IS_LOCAL(who_to_send_to))) { // an incoming reply to a whois we sent out std::string nick_whoised = prefix; unsigned long signon = atoi(params[1].c_str()); unsigned long idle = atoi(params[2].c_str()); if ((who_to_send_to) && (IS_LOCAL(who_to_send_to))) { do_whois(this->Instance, who_to_send_to, u, signon, idle, nick_whoised.c_str()); } } else { // not ours, pass it on if (who_to_send_to) Utils->DoOneToOne(prefix, "IDLE", params, who_to_send_to->server); } } } return true; } bool TreeSocket::Push(const std::string &prefix, std::deque ¶ms) { if (params.size() < 2) return true; userrec* u = this->Instance->FindNick(params[0]); if (!u) return true; if (IS_LOCAL(u)) { u->Write(params[1]); } else { // continue the raw onwards params[1] = ":" + params[1]; Utils->DoOneToOne(prefix,"PUSH",params,u->server); } return true; } bool TreeSocket::HandleSetTime(const std::string &prefix, std::deque ¶ms) { if (!params.size() || !Utils->EnableTimeSync) return true; bool force = false; if ((params.size() == 2) && (params[1] == "FORCE")) force = true; time_t them = atoi(params[0].c_str()); time_t us = Instance->Time(false); time_t diff = them - us; Utils->DoOneToAllButSender(prefix, "TIMESET", params, prefix); if (force || (them != us)) { time_t old = Instance->SetTimeDelta(diff); Instance->Log(DEBUG, "TS (diff %d) from %s applied (old delta was %d)", diff, prefix.c_str(), old); } return true; } bool TreeSocket::Time(const std::string &prefix, std::deque ¶ms) { // :source.server TIME remote.server sendernick // :remote.server TIME source.server sendernick TS if (params.size() == 2) { // someone querying our time? if (this->Instance->Config->ServerName == params[0]) { userrec* u = this->Instance->FindNick(params[1]); if (u) { params.push_back(ConvToStr(Instance->Time(false))); params[0] = prefix; Utils->DoOneToOne(this->Instance->Config->ServerName,"TIME",params,params[0]); } } else { // not us, pass it on userrec* u = this->Instance->FindNick(params[1]); if (u) Utils->DoOneToOne(prefix,"TIME",params,params[0]); } } else if (params.size() == 3) { // a response to a previous TIME userrec* u = this->Instance->FindNick(params[1]); if ((u) && (IS_LOCAL(u))) { time_t rawtime = atol(params[2].c_str()); struct tm * timeinfo; timeinfo = localtime(&rawtime); char tms[26]; snprintf(tms,26,"%s",asctime(timeinfo)); tms[24] = 0; u->WriteServ("391 %s %s :%s",u->nick,prefix.c_str(),tms); } else { if (u) Utils->DoOneToOne(prefix,"TIME",params,u->server); } } return true; } bool TreeSocket::LocalPing(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; if (params.size() == 1) { std::string stufftobounce = params[0]; this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" PONG "+stufftobounce); return true; } else { std::string forwardto = params[1]; if (forwardto == this->Instance->Config->ServerName) { // this is a ping for us, send back PONG to the requesting server params[1] = params[0]; params[0] = forwardto; Utils->DoOneToOne(forwardto,"PONG",params,params[1]); } else { // not for us, pass it on :) Utils->DoOneToOne(prefix,"PING",params,forwardto); } return true; } } /** TODO: This creates a total mess of output and needs to really use irc::modestacker. */ bool TreeSocket::RemoveStatus(const std::string &prefix, std::deque ¶ms) { if (params.size() < 1) return true; chanrec* c = Instance->FindChan(params[0]); if (c) { for (char modeletter = 'A'; modeletter <= 'z'; modeletter++) { ModeHandler* mh = Instance->Modes->FindMode(modeletter, MODETYPE_CHANNEL); if (mh) mh->RemoveMode(c); } } return true; } bool TreeSocket::RemoteServer(const std::string &prefix, std::deque ¶ms) { if (params.size() < 4) return false; std::string servername = params[0]; std::string password = params[1]; // hopcount is not used for a remote server, we calculate this ourselves std::string description = params[3]; TreeServer* ParentOfThis = Utils->FindServer(prefix); if (!ParentOfThis) { this->SendError("Protocol error - Introduced remote server from unknown server "+prefix); return false; } TreeServer* CheckDupe = Utils->FindServer(servername); if (CheckDupe) { this->SendError("Server "+servername+" already exists!"); this->Instance->SNO->WriteToSnoMask('l',"Server \2"+servername+"\2 being introduced from \2" + prefix + "\2 denied, already exists. Closing link with " + prefix); return false; } Link* lnk = Utils->FindLink(servername); TreeServer* Node = new TreeServer(this->Utils,this->Instance,servername,description,ParentOfThis,NULL, lnk ? lnk->Hidden : false); ParentOfThis->AddChild(Node); params[3] = ":" + params[3]; Utils->SetRemoteBursting(Node, true); Utils->DoOneToAllButSender(prefix,"SERVER",params,prefix); this->Instance->SNO->WriteToSnoMask('l',"Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")"); return true; } bool TreeSocket::ComparePass(const std::string &ours, const std::string &theirs) { if ((!strncmp(ours.c_str(), "HMAC-SHA256:", 12)) || (!strncmp(theirs.c_str(), "HMAC-SHA256:", 12))) { /* One or both of us specified hmac sha256, but we don't have sha256 module loaded! * We can't allow this password as valid. */ if (!Instance->FindModule("m_sha256.so") || !Utils->ChallengeResponse) return false; else /* Straight string compare of hashes */ return ours == theirs; } else /* Straight string compare of plaintext */ return ours == theirs; } bool TreeSocket::Outbound_Reply_Server(std::deque ¶ms) { if (params.size() < 4) return false; irc::string servername = params[0].c_str(); std::string sname = params[0]; std::string password = params[1]; std::string description = params[3]; int hops = atoi(params[2].c_str()); this->InboundServerName = sname; this->InboundDescription = description; if (!sentcapab) this->SendCapabilities(); if (hops) { this->SendError("Server too far away for authentication"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); return false; } for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password)) || (x->RecvPass == password && (this->GetTheirChallenge().empty())))) { TreeServer* CheckDupe = Utils->FindServer(sname); if (CheckDupe) { this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); return false; } // Begin the sync here. this kickstarts the // other side, waiting in WAIT_AUTH_2 state, // into starting their burst, as it shows // that we're happy. this->LinkState = CONNECTED; // 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->Utils,this->Instance,sname,description,Utils->TreeRoot,this,x->Hidden); Utils->TreeRoot->AddChild(Node); params[3] = ":" + params[3]; Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,sname); this->bursting = true; this->DoBurst(Node); return true; } } this->SendError("Invalid credentials"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials"); return false; } bool TreeSocket::Inbound_Server(std::deque ¶ms) { if (params.size() < 4) return false; irc::string servername = params[0].c_str(); std::string sname = params[0]; std::string password = params[1]; std::string description = params[3]; int hops = atoi(params[2].c_str()); this->InboundServerName = sname; this->InboundDescription = description; if (!sentcapab) this->SendCapabilities(); if (hops) { this->SendError("Server too far away for authentication"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); return false; } for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) { if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password) || x->RecvPass == password && (this->GetTheirChallenge().empty())))) { /* First check for instances of the server that are waiting between the inbound and outbound SERVER command */ TreeSocket* CheckDupeSocket = Utils->FindBurstingServer(sname); if (CheckDupeSocket) { /* If we find one, we abort the link to prevent a race condition */ this->SendError("Negotiation collision"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists in a negotiating state."); CheckDupeSocket->SendError("Negotiation collision"); Instance->SE->DelFd(CheckDupeSocket); CheckDupeSocket->Close(); delete CheckDupeSocket; return false; } /* Now check for fully initialized instances of the server */ TreeServer* CheckDupe = Utils->FindServer(sname); if (CheckDupe) { this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); return false; } this->Instance->SNO->WriteToSnoMask('l',"Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "" : this->GetIP())+"] ("+description+")"); if (this->Hook) { std::string name = InspSocketNameRequest((Module*)Utils->Creator, this->Hook).Send(); this->Instance->SNO->WriteToSnoMask('l',"Connection from \2"+sname+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] using transport \2"+name+"\2"); } Utils->AddBurstingServer(sname,this); // this is good. Send our details: Our server name and description and hopcount of 0, // along with the sendpass from this block. this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(x->SendPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc); // move to the next state, we are now waiting for THEM. this->LinkState = WAIT_AUTH_2; return true; } } this->SendError("Invalid credentials"); this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials"); return false; } void TreeSocket::Split(const std::string &line, std::deque &n) { n.clear(); irc::tokenstream tokens(line); std::string param; while (tokens.GetToken(param)) { if (!param.empty()) n.push_back(param); } return; } bool TreeSocket::ProcessLine(std::string &line) { std::deque params; irc::string command; std::string prefix; line = line.substr(0, line.find_first_of("\r\n")); if (line.empty()) return true; Instance->Log(DEBUG, "S[%d] <- %s", this->GetFd(), line.c_str()); this->Split(line.c_str(),params); if (params.empty()) return true; if ((params[0][0] == ':') && (params.size() > 1)) { prefix = params[0].substr(1); params.pop_front(); } command = params[0].c_str(); params.pop_front(); switch (this->LinkState) { TreeServer* Node; case WAIT_AUTH_1: // Waiting for SERVER command from remote server. Server initiating // the connection sends the first SERVER command, listening server // replies with theirs if its happy, then if the initiator is happy, // it starts to send its net sync, which starts the merge, otherwise // it sends an ERROR. if (command == "PASS") { /* Silently ignored */ } else if (command == "SERVER") { return this->Inbound_Server(params); } else if (command == "ERROR") { return this->Error(params); } else if (command == "USER") { this->SendError("Client connections to this port are prohibited."); return false; } else if (command == "CAPAB") { return this->Capab(params); } else if ((command == "U") || (command == "S")) { this->SendError("Cannot use the old-style mesh linking protocol with m_spanningtree.so!"); return false; } else { irc::string error = "Invalid command in negotiation phase: " + command; this->SendError(assign(error)); return false; } break; case WAIT_AUTH_2: // Waiting for start of other side's netmerge to say they liked our // password. if (command == "SERVER") { // cant do this, they sent it to us in the WAIT_AUTH_1 state! // silently ignore. return true; } else if ((command == "U") || (command == "S")) { this->SendError("Cannot use the old-style mesh linking protocol with m_spanningtree.so!"); return false; } else if (command == "BURST") { if (params.size() && Utils->EnableTimeSync) { bool we_have_delta = (Instance->Time(false) != Instance->Time(true)); time_t them = atoi(params[0].c_str()); time_t delta = them - Instance->Time(false); if ((delta < -300) || (delta > 300)) { Instance->SNO->WriteToSnoMask('l',"\2ERROR\2: Your clocks are out by %d seconds (this is more than five minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta)); SendError("Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than five minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!"); return false; } else if ((delta < -30) || (delta > 30)) { Instance->SNO->WriteToSnoMask('l',"\2WARNING\2: Your clocks are out by %d seconds. Please consider synching your clocks.", abs(delta)); } if (!Utils->MasterTime && !we_have_delta) { this->Instance->SetTimeDelta(delta); // Send this new timestamp to any other servers Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params); } } this->LinkState = CONNECTED; Link* lnk = Utils->FindLink(InboundServerName); Node = new TreeServer(this->Utils,this->Instance, InboundServerName, InboundDescription, Utils->TreeRoot, this, lnk ? lnk->Hidden : false); Utils->DelBurstingServer(this); Utils->TreeRoot->AddChild(Node); params.clear(); params.push_back(InboundServerName); params.push_back("*"); params.push_back("1"); params.push_back(":"+InboundDescription); Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,InboundServerName); this->bursting = true; this->DoBurst(Node); } else if (command == "ERROR") { return this->Error(params); } else if (command == "CAPAB") { return this->Capab(params); } break; case LISTENER: this->SendError("Internal error -- listening socket accepted its own descriptor!!!"); return false; break; case CONNECTING: if (command == "SERVER") { // another server we connected to, which was in WAIT_AUTH_1 state, // has just sent us their credentials. If we get this far, theyre // happy with OUR credentials, and they are now in WAIT_AUTH_2 state. // if we're happy with this, we should send our netburst which // kickstarts the merge. return this->Outbound_Reply_Server(params); } else if (command == "ERROR") { return this->Error(params); } else if (command == "CAPAB") { return this->Capab(params); } break; case CONNECTED: // This is the 'authenticated' state, when all passwords // have been exchanged and anything past this point is taken // as gospel. if (!prefix.empty()) { std::string direction = prefix; userrec* t = this->Instance->FindNick(prefix); if (t) { direction = t->server; } TreeServer* route_back_again = Utils->BestRouteTo(direction); if ((!route_back_again) || (route_back_again->GetSocket() != this)) { if (route_back_again) Instance->Log(DEBUG,"Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str()); return true; } /* Fix by brain: * When there is activity on the socket, reset the ping counter so * that we're not wasting bandwidth pinging an active server. */ route_back_again->SetNextPingTime(time(NULL) + 60); route_back_again->SetPingFlag(); } else { prefix = this->GetName(); } if ((command == "MODE") && (params.size() >= 2)) { chanrec* channel = Instance->FindChan(params[0]); if (channel) { userrec* x = Instance->FindNick(prefix); if (x) { if (warned.find(x->server) == warned.end()) { Instance->Log(DEFAULT,"WARNING: I revceived modes '%s' from another server '%s'. This is not compliant with InspIRCd. Please check that server for bugs.", params[1].c_str(), x->server); Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending nonstandard modes: '%s MODE %s' where FMODE should be used, and may cause desyncs.", x->server, x->nick, params[1].c_str()); warned[x->server] = x->nick; } } } } if (command == "SVSMODE") { /* Services expects us to implement * SVSMODE. In inspircd its the same as * MODE anyway. */ command = "MODE"; } std::string target; /* Yes, know, this is a mess. Its reasonably fast though as we're * working with std::string here. */ if ((command == "NICK") && (params.size() >= 8)) { return this->IntroduceClient(prefix,params); } else if (command == "FJOIN") { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); return this->ForceJoin(prefix,params); } else if (command == "STATS") { return this->Stats(prefix, params); } else if (command == "MOTD") { return this->Motd(prefix, params); } else if (command == "KILL" && Utils->IsServer(prefix)) { return this->RemoteKill(prefix,params); } else if (command == "MODULES") { return this->Modules(prefix, params); } else if (command == "ADMIN") { return this->Admin(prefix, params); } else if (command == "SERVER") { return this->RemoteServer(prefix,params); } else if (command == "ERROR") { return this->Error(params); } else if (command == "OPERTYPE") { return this->OperType(prefix,params); } else if (command == "FMODE") { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); return this->ForceMode(prefix,params); } else if (command == "FTOPIC") { return this->ForceTopic(prefix,params); } else if (command == "REHASH") { return this->RemoteRehash(prefix,params); } else if (command == "METADATA") { return this->MetaData(prefix,params); } else if (command == "REMSTATUS") { return this->RemoveStatus(prefix,params); } else if (command == "PING") { if (prefix.empty()) prefix = this->GetName(); /* * We just got a ping from a server that's bursting. * This can't be right, so set them to not bursting, and * apply their lines. */ TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); if (this->bursting) { this->bursting = false; Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; } return this->LocalPing(prefix,params); } else if (command == "PONG") { if (prefix.empty()) prefix = this->GetName(); /* * We just got a pong from a server that's bursting. * This can't be right, so set them to not bursting, and * apply their lines. */ TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); if (this->bursting) { this->bursting = false; Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; } return this->LocalPong(prefix,params); } else if (command == "VERSION") { return this->ServerVersion(prefix,params); } else if (command == "FHOST") { return this->ChangeHost(prefix,params); } else if (command == "FNAME") { return this->ChangeName(prefix,params); } else if (command == "ADDLINE") { TreeServer* ServerSource = Utils->FindServer(prefix); if (ServerSource) Utils->SetRemoteBursting(ServerSource, false); return this->AddLine(prefix,params); } else if (command == "SVSNICK") { if (prefix.empty()) { prefix = this->GetName(); } return this->ForceNick(prefix,params); } else if (command == "OPERQUIT") { return this->OperQuit(prefix,params); } else if (command == "IDLE") { return this->Whois(prefix,params); } else if (command == "PUSH") { return this->Push(prefix,params); } else if (command == "TIMESET") { return this->HandleSetTime(prefix, params); } else if (command == "TIME") { return this->Time(prefix,params); } else if ((command == "KICK") && (Utils->IsServer(prefix))) { std::string sourceserv = this->myhost; if (params.size() == 3) { userrec* user = this->Instance->FindNick(params[1]); chanrec* chan = this->Instance->FindChan(params[0]); if (user && chan) { if (!chan->ServerKickUser(user, params[2].c_str(), false)) /* Yikes, the channels gone! */ delete chan; } } if (!this->InboundServerName.empty()) { sourceserv = this->InboundServerName; } return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } else if (command == "SVSJOIN") { if (prefix.empty()) { prefix = this->GetName(); } return this->ServiceJoin(prefix,params); } else if (command == "SQUIT") { if (params.size() == 2) { this->Squit(Utils->FindServer(params[0]),params[1]); } return true; } else if (command == "OPERNOTICE") { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; if (params.size() >= 1) Instance->WriteOpers("*** From " + sourceserv + ": " + params[0]); return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); } else if (command == "MODENOTICE") { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; if (params.size() >= 2) { Instance->WriteMode(params[0].c_str(), WM_AND, "*** From %s: %s", sourceserv.c_str(), params[1].c_str()); } return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); } else if (command == "SNONOTICE") { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; if (params.size() >= 2) { Instance->SNO->WriteToSnoMask(*(params[0].c_str()), "From " + sourceserv + ": "+ params[1]); } return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); } else if (command == "ENDBURST") { this->bursting = false; Instance->XLines->apply_lines(Utils->lines_to_apply); Utils->lines_to_apply = 0; std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) sourceserv = this->InboundServerName; this->Instance->SNO->WriteToSnoMask('l',"Received end of netburst from \2%s\2",sourceserv.c_str()); Event rmode((char*)sourceserv.c_str(), (Module*)Utils->Creator, "new_server"); rmode.Send(Instance); return true; } else { // not a special inter-server command. // Emulate the actual user doing the command, // this saves us having a huge ugly parser. userrec* who = this->Instance->FindNick(prefix); std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) { sourceserv = this->InboundServerName; } if ((!who) && (command == "MODE")) { if (Utils->IsServer(prefix)) { const char* modelist[127]; for (size_t i = 0; i < params.size(); i++) modelist[i] = params[i].c_str(); userrec* fake = new userrec(Instance); fake->SetFd(FD_MAGIC_NUMBER); this->Instance->SendMode(modelist, params.size(), fake); delete fake; /* Hot potato! pass it on! */ return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } } if (who) { if ((command == "NICK") && (params.size() > 0)) { /* On nick messages, check that the nick doesnt * already exist here. If it does, kill their copy, * and our copy. */ userrec* x = this->Instance->FindNick(params[0]); if ((x) && (x != who)) { std::deque p; p.push_back(params[0]); p.push_back("Nickname collision ("+prefix+" -> "+params[0]+")"); Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p); p.clear(); p.push_back(prefix); p.push_back("Nickname collision"); 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 Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } } // its a user target = who->server; const char* strparams[127]; for (unsigned int q = 0; q < params.size(); q++) { strparams[q] = params[q].c_str(); } switch (this->Instance->CallCommandHandler(command.c_str(), strparams, params.size(), who)) { case CMD_INVALID: this->SendError("Unrecognised command '"+std::string(command.c_str())+"' -- possibly loaded mismatched modules"); return false; break; case CMD_FAILURE: return true; break; default: /* CMD_SUCCESS and CMD_USER_DELETED fall through here */ break; } } else { // its not a user. Its either a server, or somethings screwed up. if (Utils->IsServer(prefix)) target = this->Instance->Config->ServerName; else return true; } return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); } return true; break; } return true; } std::string TreeSocket::GetName() { std::string sourceserv = this->myhost; if (!this->InboundServerName.empty()) { sourceserv = this->InboundServerName; } return sourceserv; } void TreeSocket::OnTimeout() { if (this->LinkState == CONNECTING) { this->Instance->SNO->WriteToSnoMask('l',"CONNECT: Connection to \002"+myhost+"\002 timed out."); Link* MyLink = Utils->FindLink(myhost); if (MyLink) Utils->DoFailOver(MyLink); } } void TreeSocket::OnClose() { // Connection closed. // If the connection is fully up (state CONNECTED) // then propogate a netsplit to all peers. std::string quitserver = this->myhost; if (!this->InboundServerName.empty()) { quitserver = this->InboundServerName; } TreeServer* s = Utils->FindServer(quitserver); if (s) { Squit(s,"Remote host closed the connection"); } if (!quitserver.empty()) { this->Instance->SNO->WriteToSnoMask('l',"Connection to '\2%s\2' failed.",quitserver.c_str()); time_t server_uptime = Instance->Time() - this->age; if (server_uptime) Instance->SNO->WriteToSnoMask('l',"Connection to '\2%s\2' was established for %s", quitserver.c_str(), Utils->Creator->TimeToStr(server_uptime).c_str()); } } int TreeSocket::OnIncomingConnection(int newsock, char* ip) { /* To prevent anyone from attempting to flood opers/DDoS by connecting to the server port, * or discovering if this port is the server port, we don't allow connections from any * IPs for which we don't have a link block. */ bool found = false; found = (std::find(Utils->ValidIPs.begin(), Utils->ValidIPs.end(), ip) != Utils->ValidIPs.end()); if (!found) { for (vector::iterator i = Utils->ValidIPs.begin(); i != Utils->ValidIPs.end(); i++) if (irc::sockets::MatchCIDR(ip, (*i).c_str())) found = true; if (!found) { this->Instance->SNO->WriteToSnoMask('l',"Server connection from %s denied (no link blocks with that IP address)", ip); close(newsock); return false; } } TreeSocket* s = new TreeSocket(this->Utils, this->Instance, newsock, ip, this->Hook); s = s; /* Whinge whinge whinge, thats all GCC ever does. */ return true; } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" +#include "socketengine.h" + +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" +#include "m_spanningtree/resolvers.h" +#include "m_spanningtree/handshaketimer.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ + +static std::map warned; /* Server names that have had protocol violation warnings displayed for them */ + +int TreeSocket::WriteLine(std::string line) +{ + Instance->Log(DEBUG, "S[%d] -> %s", this->GetFd(), line.c_str()); + line.append("\r\n"); + return this->Write(line); +} + + +/* Handle ERROR command */ +bool TreeSocket::Error(std::deque ¶ms) +{ + if (params.size() < 1) + return false; + this->Instance->SNO->WriteToSnoMask('l',"ERROR from %s: %s",(!InboundServerName.empty() ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str()); + /* we will return false to cause the socket to close. */ + return false; +} + +bool TreeSocket::Modules(const std::string &prefix, std::deque ¶ms) +{ + if (params.empty()) + return true; + + if (!this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) + { + /* Pass it on, not for us */ + Utils->DoOneToOne(prefix, "MODULES", params, params[0]); + return true; + } + + char strbuf[MAXBUF]; + std::deque par; + par.push_back(prefix); + par.push_back(""); + + userrec* source = this->Instance->FindNick(prefix); + if (!source) + return true; + + for (unsigned int i = 0; i < Instance->Config->module_names.size(); i++) + { + Version V = Instance->modules[i]->GetVersion(); + char modulename[MAXBUF]; + char flagstate[MAXBUF]; + *flagstate = 0; + if (V.Flags & VF_STATIC) + strlcat(flagstate,", static",MAXBUF); + if (V.Flags & VF_VENDOR) + strlcat(flagstate,", vendor",MAXBUF); + if (V.Flags & VF_COMMON) + strlcat(flagstate,", common",MAXBUF); + if (V.Flags & VF_SERVICEPROVIDER) + strlcat(flagstate,", service provider",MAXBUF); + if (!flagstate[0]) + strcpy(flagstate," "); + strlcpy(modulename,Instance->Config->module_names[i].c_str(),256); + if (*source->oper) + { + snprintf(strbuf, MAXBUF, "::%s 900 %s :0x%08lx %d.%d.%d.%d %s (%s)",Instance->Config->ServerName,source->nick,(long unsigned int)Instance->modules[i],V.Major,V.Minor,V.Revision,V.Build,ServerConfig::CleanFilename(modulename),flagstate+2); + } + else + { + snprintf(strbuf, MAXBUF, "::%s 900 %s :%s",Instance->Config->ServerName,source->nick,ServerConfig::CleanFilename(modulename)); + } + par[1] = strbuf; + Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server); + } + snprintf(strbuf, MAXBUF, "::%s 901 %s :End of MODULES list", Instance->Config->ServerName, source->nick); + par[1] = strbuf; + Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server); + return true; +} + +/** remote MOTD. leet, huh? */ +bool TreeSocket::Motd(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() > 0) + { + if (this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) + { + /* It's for our server */ + string_list results; + userrec* source = this->Instance->FindNick(prefix); + + if (source) + { + std::deque par; + par.push_back(prefix); + par.push_back(""); + + if (!Instance->Config->MOTD.size()) + { + par[1] = std::string("::")+Instance->Config->ServerName+" 422 "+source->nick+" :Message of the day file is missing."; + 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"; + 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]; + 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."; + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + } + } + else + { + /* Pass it on */ + userrec* source = this->Instance->FindNick(prefix); + if (source) + Utils->DoOneToOne(prefix, "MOTD", params, params[0]); + } + } + return true; +} + +/** remote ADMIN. leet, huh? */ +bool TreeSocket::Admin(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() > 0) + { + if (this->Instance->MatchText(this->Instance->Config->ServerName, params[0])) + { + /* It's for our server */ + string_list results; + userrec* source = this->Instance->FindNick(prefix); + if (source) + { + std::deque par; + par.push_back(prefix); + par.push_back(""); + par[1] = std::string("::")+Instance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+Instance->Config->ServerName; + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + par[1] = std::string("::")+Instance->Config->ServerName+" 257 "+source->nick+" :Name - "+Instance->Config->AdminName; + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :Nickname - "+Instance->Config->AdminNick; + 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; + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + } + } + else + { + /* Pass it on */ + userrec* source = this->Instance->FindNick(prefix); + if (source) + Utils->DoOneToOne(prefix, "ADMIN", params, params[0]); + } + } + return true; +} + +bool TreeSocket::Stats(const std::string &prefix, std::deque ¶ms) +{ + /* Get the reply to a STATS query if it matches this servername, + * and send it back as a load of PUSH queries + */ + if (params.size() > 1) + { + if (this->Instance->MatchText(this->Instance->Config->ServerName, params[1])) + { + /* It's for our server */ + string_list results; + userrec* source = this->Instance->FindNick(prefix); + if (source) + { + std::deque par; + par.push_back(prefix); + par.push_back(""); + DoStats(this->Instance, *(params[0].c_str()), source, results); + for (size_t i = 0; i < results.size(); i++) + { + par[1] = "::" + results[i]; + Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server); + } + } + } + else + { + /* Pass it on */ + userrec* source = this->Instance->FindNick(prefix); + if (source) + Utils->DoOneToOne(prefix, "STATS", params, params[1]); + } + } + return true; +} + + +/** Because the core won't let users or even SERVERS set +o, + * we use the OPERTYPE command to do this. + */ +bool TreeSocket::OperType(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() != 1) + return true; + std::string opertype = params[0]; + userrec* u = this->Instance->FindNick(prefix); + if (u) + { + u->modes[UM_OPERATOR] = 1; + this->Instance->all_opers.push_back(u); + strlcpy(u->oper,opertype.c_str(),NICKMAX-1); + Utils->DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server); + this->Instance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick,u->ident,u->host,irc::Spacify(opertype.c_str())); + } + return true; +} + +/** Because Andy insists that services-compatible servers must + * implement SVSNICK and SVSJOIN, that's exactly what we do :p + */ +bool TreeSocket::ForceNick(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 3) + return true; + + userrec* u = this->Instance->FindNick(params[0]); + + if (u) + { + Utils->DoOneToAllButSender(prefix,"SVSNICK",params,prefix); + if (IS_LOCAL(u)) + { + std::deque par; + par.push_back(params[1]); + if (!u->ForceNickChange(params[1].c_str())) + { + userrec::QuitUser(this->Instance, u, "Nickname collision"); + return true; + } + u->age = atoi(params[2].c_str()); + } + } + return true; +} + +bool TreeSocket::OperQuit(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + + userrec* u = this->Instance->FindNick(prefix); + + if (u) + { + u->SetOperQuit(params[0]); + params[0] = ":" + params[0]; + Utils->DoOneToAllButSender(prefix,"OPERQUIT",params,prefix); + } + return true; +} + +bool TreeSocket::ServiceJoin(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 2) + return true; + + userrec* u = this->Instance->FindNick(params[0]); + + if (u) + { + /* only join if it's local, otherwise just pass it on! */ + if (IS_LOCAL(u)) + chanrec::JoinUser(this->Instance, u, params[1].c_str(), false, "", Instance->Time()); + Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix); + } + return true; +} + +bool TreeSocket::RemoteRehash(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return false; + + std::string servermask = params[0]; + + if (this->Instance->MatchText(this->Instance->Config->ServerName,servermask)) + { + this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated by \002"+prefix+"\002."); + this->Instance->RehashServer(); + Utils->ReadConfiguration(false); + InitializeDisabledCommands(Instance->Config->DisabledCommands, Instance); + } + Utils->DoOneToAllButSender(prefix,"REHASH",params,prefix); + return true; +} + +bool TreeSocket::RemoteKill(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() != 2) + return true; + + userrec* who = this->Instance->FindNick(params[0]); + + if (who) + { + /* Prepend kill source, if we don't have one */ + if (*(params[1].c_str()) != '[') + { + params[1] = "[" + prefix + "] Killed (" + params[1] +")"; + } + std::string reason = params[1]; + params[1] = ":" + params[1]; + Utils->DoOneToAllButSender(prefix,"KILL",params,prefix); + // NOTE: This is safe with kill hiding on, as RemoteKill is only reached if we have a server prefix. + // in short this is not executed for USERS. + who->Write(":%s KILL %s :%s (%s)", prefix.c_str(), who->nick, prefix.c_str(), reason.c_str()); + userrec::QuitUser(this->Instance,who,reason); + } + return true; +} + +bool TreeSocket::LocalPong(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + + if (params.size() == 1) + { + TreeServer* ServerSource = Utils->FindServer(prefix); + if (ServerSource) + { + ServerSource->SetPingFlag(); + ServerSource->rtt = Instance->Time() - ServerSource->LastPing; + } + } + else + { + std::string forwardto = params[1]; + if (forwardto == this->Instance->Config->ServerName) + { + /* + * this is a PONG for us + * if the prefix is a user, check theyre local, and if they are, + * dump the PONG reply back to their fd. If its a server, do nowt. + * Services might want to send these s->s, but we dont need to yet. + */ + userrec* u = this->Instance->FindNick(prefix); + if (u) + { + u->WriteServ("PONG %s %s",params[0].c_str(),params[1].c_str()); + } + } + else + { + // not for us, pass it on :) + Utils->DoOneToOne(prefix,"PONG",params,forwardto); + } + } + + return true; +} + +bool TreeSocket::MetaData(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 2) + return true; + else if (params.size() < 3) + params.push_back(""); + TreeServer* ServerSource = Utils->FindServer(prefix); + if (ServerSource) + { + Utils->SetRemoteBursting(ServerSource, false); + + if (params[0] == "*") + { + FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_OTHER,NULL,params[1],params[2])); + } + else if (*(params[0].c_str()) == '#') + { + chanrec* c = this->Instance->FindChan(params[0]); + if (c) + { + FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2])); + } + } + else if (*(params[0].c_str()) != '#') + { + userrec* u = this->Instance->FindNick(params[0]); + if (u) + { + FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2])); + } + } + } + + params[2] = ":" + params[2]; + Utils->DoOneToAllButSender(prefix,"METADATA",params,prefix); + return true; +} + +bool TreeSocket::ServerVersion(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + + TreeServer* ServerSource = Utils->FindServer(prefix); + + if (ServerSource) + { + ServerSource->SetVersion(params[0]); + } + params[0] = ":" + params[0]; + Utils->DoOneToAllButSender(prefix,"VERSION",params,prefix); + return true; +} + +bool TreeSocket::ChangeHost(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + userrec* u = this->Instance->FindNick(prefix); + + if (u) + { + u->ChangeDisplayedHost(params[0].c_str()); + Utils->DoOneToAllButSender(prefix,"FHOST",params,u->server); + } + return true; +} + +bool TreeSocket::AddLine(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 6) + return true; + bool propogate = false; + if (!this->bursting) + Utils->lines_to_apply = 0; + switch (*(params[0].c_str())) + { + case 'Z': + propogate = Instance->XLines->add_zline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + Instance->XLines->zline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); + if (propogate) + Utils->lines_to_apply |= APPLY_ZLINES; + break; + case 'Q': + propogate = Instance->XLines->add_qline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + Instance->XLines->qline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); + if (propogate) + Utils->lines_to_apply |= APPLY_QLINES; + break; + case 'E': + propogate = Instance->XLines->add_eline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + Instance->XLines->eline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); + break; + case 'G': + propogate = Instance->XLines->add_gline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + Instance->XLines->gline_set_creation_time(params[1].c_str(), atoi(params[3].c_str())); + if (propogate) + Utils->lines_to_apply |= APPLY_GLINES; + break; + case 'K': + propogate = Instance->XLines->add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str()); + if (propogate) + Utils->lines_to_apply |= APPLY_KLINES; + break; + default: + /* Just in case... */ + this->Instance->SNO->WriteToSnoMask('x',"\2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!"); + propogate = false; + break; + } + /* Send it on its way */ + if (propogate) + { + if (atoi(params[4].c_str())) + { + time_t c_requires_crap = ConvToInt(params[4]) + Instance->Time(); + this->Instance->SNO->WriteToSnoMask('x',"%s Added %cLINE on %s to expire on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),Instance->TimeString(c_requires_crap).c_str(),params[5].c_str()); + } + else + { + 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]; + Utils->DoOneToAllButSender(prefix,"ADDLINE",params,prefix); + } + if (!this->bursting) + { + Instance->XLines->apply_lines(Utils->lines_to_apply); + Utils->lines_to_apply = 0; + } + return true; +} + +bool TreeSocket::ChangeName(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + userrec* u = this->Instance->FindNick(prefix); + if (u) + { + u->ChangeName(params[0].c_str()); + params[0] = ":" + params[0]; + Utils->DoOneToAllButSender(prefix,"FNAME",params,u->server); + } + return true; +} + +bool TreeSocket::Whois(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + userrec* u = this->Instance->FindNick(prefix); + if (u) + { + // an incoming request + if (params.size() == 1) + { + userrec* x = this->Instance->FindNick(params[0]); + if ((x) && (IS_LOCAL(x))) + { + userrec* x = this->Instance->FindNick(params[0]); + char signon[MAXBUF]; + char idle[MAXBUF]; + snprintf(signon, MAXBUF, "%lu", (unsigned long)x->signon); + snprintf(idle, MAXBUF, "%lu", (unsigned long)abs((x->idle_lastmsg) - Instance->Time(true))); + std::deque par; + par.push_back(prefix); + par.push_back(signon); + par.push_back(idle); + // ours, we're done, pass it BACK + Utils->DoOneToOne(params[0], "IDLE", par, u->server); + } + else + { + // not ours pass it on + if (x) + Utils->DoOneToOne(prefix, "IDLE", params, x->server); + } + } + else if (params.size() == 3) + { + std::string who_did_the_whois = params[0]; + userrec* who_to_send_to = this->Instance->FindNick(who_did_the_whois); + if ((who_to_send_to) && (IS_LOCAL(who_to_send_to))) + { + // an incoming reply to a whois we sent out + std::string nick_whoised = prefix; + unsigned long signon = atoi(params[1].c_str()); + unsigned long idle = atoi(params[2].c_str()); + if ((who_to_send_to) && (IS_LOCAL(who_to_send_to))) + { + do_whois(this->Instance, who_to_send_to, u, signon, idle, nick_whoised.c_str()); + } + } + else + { + // not ours, pass it on + if (who_to_send_to) + Utils->DoOneToOne(prefix, "IDLE", params, who_to_send_to->server); + } + } + } + return true; +} + +bool TreeSocket::Push(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 2) + return true; + userrec* u = this->Instance->FindNick(params[0]); + if (!u) + return true; + if (IS_LOCAL(u)) + { + u->Write(params[1]); + } + else + { + // continue the raw onwards + params[1] = ":" + params[1]; + Utils->DoOneToOne(prefix,"PUSH",params,u->server); + } + return true; +} + +bool TreeSocket::HandleSetTime(const std::string &prefix, std::deque ¶ms) +{ + if (!params.size() || !Utils->EnableTimeSync) + return true; + + bool force = false; + + if ((params.size() == 2) && (params[1] == "FORCE")) + force = true; + + time_t them = atoi(params[0].c_str()); + time_t us = Instance->Time(false); + + time_t diff = them - us; + + Utils->DoOneToAllButSender(prefix, "TIMESET", params, prefix); + + if (force || (them != us)) + { + time_t old = Instance->SetTimeDelta(diff); + Instance->Log(DEBUG, "TS (diff %d) from %s applied (old delta was %d)", diff, prefix.c_str(), old); + } + + return true; +} + +bool TreeSocket::Time(const std::string &prefix, std::deque ¶ms) +{ + // :source.server TIME remote.server sendernick + // :remote.server TIME source.server sendernick TS + if (params.size() == 2) + { + // someone querying our time? + if (this->Instance->Config->ServerName == params[0]) + { + userrec* u = this->Instance->FindNick(params[1]); + if (u) + { + params.push_back(ConvToStr(Instance->Time(false))); + params[0] = prefix; + Utils->DoOneToOne(this->Instance->Config->ServerName,"TIME",params,params[0]); + } + } + else + { + // not us, pass it on + userrec* u = this->Instance->FindNick(params[1]); + if (u) + Utils->DoOneToOne(prefix,"TIME",params,params[0]); + } + } + else if (params.size() == 3) + { + // a response to a previous TIME + userrec* u = this->Instance->FindNick(params[1]); + if ((u) && (IS_LOCAL(u))) + { + time_t rawtime = atol(params[2].c_str()); + struct tm * timeinfo; + timeinfo = localtime(&rawtime); + char tms[26]; + snprintf(tms,26,"%s",asctime(timeinfo)); + tms[24] = 0; + u->WriteServ("391 %s %s :%s",u->nick,prefix.c_str(),tms); + } + else + { + if (u) + Utils->DoOneToOne(prefix,"TIME",params,u->server); + } + } + return true; +} + +bool TreeSocket::LocalPing(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + if (params.size() == 1) + { + std::string stufftobounce = params[0]; + this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" PONG "+stufftobounce); + return true; + } + else + { + std::string forwardto = params[1]; + if (forwardto == this->Instance->Config->ServerName) + { + // this is a ping for us, send back PONG to the requesting server + params[1] = params[0]; + params[0] = forwardto; + Utils->DoOneToOne(forwardto,"PONG",params,params[1]); + } + else + { + // not for us, pass it on :) + Utils->DoOneToOne(prefix,"PING",params,forwardto); + } + return true; + } +} + +/** TODO: This creates a total mess of output and needs to really use irc::modestacker. + */ +bool TreeSocket::RemoveStatus(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 1) + return true; + chanrec* c = Instance->FindChan(params[0]); + if (c) + { + for (char modeletter = 'A'; modeletter <= 'z'; modeletter++) + { + ModeHandler* mh = Instance->Modes->FindMode(modeletter, MODETYPE_CHANNEL); + if (mh) + mh->RemoveMode(c); + } + } + return true; +} + +bool TreeSocket::RemoteServer(const std::string &prefix, std::deque ¶ms) +{ + if (params.size() < 4) + return false; + std::string servername = params[0]; + std::string password = params[1]; + // hopcount is not used for a remote server, we calculate this ourselves + std::string description = params[3]; + TreeServer* ParentOfThis = Utils->FindServer(prefix); + if (!ParentOfThis) + { + this->SendError("Protocol error - Introduced remote server from unknown server "+prefix); + return false; + } + TreeServer* CheckDupe = Utils->FindServer(servername); + if (CheckDupe) + { + this->SendError("Server "+servername+" already exists!"); + this->Instance->SNO->WriteToSnoMask('l',"Server \2"+servername+"\2 being introduced from \2" + prefix + "\2 denied, already exists. Closing link with " + prefix); + return false; + } + Link* lnk = Utils->FindLink(servername); + TreeServer* Node = new TreeServer(this->Utils,this->Instance,servername,description,ParentOfThis,NULL, lnk ? lnk->Hidden : false); + ParentOfThis->AddChild(Node); + params[3] = ":" + params[3]; + Utils->SetRemoteBursting(Node, true); + Utils->DoOneToAllButSender(prefix,"SERVER",params,prefix); + this->Instance->SNO->WriteToSnoMask('l',"Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")"); + return true; +} + +bool TreeSocket::ComparePass(const std::string &ours, const std::string &theirs) +{ + if ((!strncmp(ours.c_str(), "HMAC-SHA256:", 12)) || (!strncmp(theirs.c_str(), "HMAC-SHA256:", 12))) + { + /* One or both of us specified hmac sha256, but we don't have sha256 module loaded! + * We can't allow this password as valid. + */ + if (!Instance->FindModule("m_sha256.so") || !Utils->ChallengeResponse) + return false; + else + /* Straight string compare of hashes */ + return ours == theirs; + } + else + /* Straight string compare of plaintext */ + return ours == theirs; +} + +bool TreeSocket::Outbound_Reply_Server(std::deque ¶ms) +{ + if (params.size() < 4) + return false; + + irc::string servername = params[0].c_str(); + std::string sname = params[0]; + std::string password = params[1]; + std::string description = params[3]; + int hops = atoi(params[2].c_str()); + + this->InboundServerName = sname; + this->InboundDescription = description; + + if (!sentcapab) + this->SendCapabilities(); + + if (hops) + { + this->SendError("Server too far away for authentication"); + this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); + return false; + } + + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) + { + if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password)) || (x->RecvPass == password && (this->GetTheirChallenge().empty())))) + { + TreeServer* CheckDupe = Utils->FindServer(sname); + if (CheckDupe) + { + this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); + this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); + return false; + } + // Begin the sync here. this kickstarts the + // other side, waiting in WAIT_AUTH_2 state, + // into starting their burst, as it shows + // that we're happy. + this->LinkState = CONNECTED; + // 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->Utils,this->Instance,sname,description,Utils->TreeRoot,this,x->Hidden); + Utils->TreeRoot->AddChild(Node); + params[3] = ":" + params[3]; + Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,sname); + this->bursting = true; + this->DoBurst(Node); + return true; + } + } + this->SendError("Invalid credentials"); + this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials"); + return false; +} + +bool TreeSocket::Inbound_Server(std::deque ¶ms) +{ + if (params.size() < 4) + return false; + irc::string servername = params[0].c_str(); + std::string sname = params[0]; + std::string password = params[1]; + std::string description = params[3]; + int hops = atoi(params[2].c_str()); + + this->InboundServerName = sname; + this->InboundDescription = description; + + if (!sentcapab) + this->SendCapabilities(); + + if (hops) + { + this->SendError("Server too far away for authentication"); + this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication"); + return false; + } + + for (std::vector::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++) + { + if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password) || x->RecvPass == password && (this->GetTheirChallenge().empty())))) + { + /* First check for instances of the server that are waiting between the inbound and outbound SERVER command */ + TreeSocket* CheckDupeSocket = Utils->FindBurstingServer(sname); + if (CheckDupeSocket) + { + /* If we find one, we abort the link to prevent a race condition */ + this->SendError("Negotiation collision"); + this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists in a negotiating state."); + CheckDupeSocket->SendError("Negotiation collision"); + Instance->SE->DelFd(CheckDupeSocket); + CheckDupeSocket->Close(); + delete CheckDupeSocket; + return false; + } + /* Now check for fully initialized instances of the server */ + TreeServer* CheckDupe = Utils->FindServer(sname); + if (CheckDupe) + { + this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!"); + this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName()); + return false; + } + this->Instance->SNO->WriteToSnoMask('l',"Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "" : this->GetIP())+"] ("+description+")"); + if (this->Hook) + { + std::string name = InspSocketNameRequest((Module*)Utils->Creator, this->Hook).Send(); + this->Instance->SNO->WriteToSnoMask('l',"Connection from \2"+sname+"\2["+(x->HiddenFromStats ? "" : this->GetIP())+"] using transport \2"+name+"\2"); + } + + Utils->AddBurstingServer(sname,this); + + // this is good. Send our details: Our server name and description and hopcount of 0, + // along with the sendpass from this block. + this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(x->SendPass, this->GetTheirChallenge())+" 0 :"+this->Instance->Config->ServerDesc); + // move to the next state, we are now waiting for THEM. + this->LinkState = WAIT_AUTH_2; + return true; + } + } + this->SendError("Invalid credentials"); + this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials"); + return false; +} + +void TreeSocket::Split(const std::string &line, std::deque &n) +{ + n.clear(); + irc::tokenstream tokens(line); + std::string param; + while (tokens.GetToken(param)) + { + if (!param.empty()) + n.push_back(param); + } + return; +} + +bool TreeSocket::ProcessLine(std::string &line) +{ + std::deque params; + irc::string command; + std::string prefix; + + line = line.substr(0, line.find_first_of("\r\n")); + + if (line.empty()) + return true; + + Instance->Log(DEBUG, "S[%d] <- %s", this->GetFd(), line.c_str()); + + this->Split(line.c_str(),params); + + if (params.empty()) + return true; + + if ((params[0][0] == ':') && (params.size() > 1)) + { + prefix = params[0].substr(1); + params.pop_front(); + } + command = params[0].c_str(); + params.pop_front(); + switch (this->LinkState) + { + TreeServer* Node; + + case WAIT_AUTH_1: + // Waiting for SERVER command from remote server. Server initiating + // the connection sends the first SERVER command, listening server + // replies with theirs if its happy, then if the initiator is happy, + // it starts to send its net sync, which starts the merge, otherwise + // it sends an ERROR. + if (command == "PASS") + { + /* Silently ignored */ + } + else if (command == "SERVER") + { + return this->Inbound_Server(params); + } + else if (command == "ERROR") + { + return this->Error(params); + } + else if (command == "USER") + { + this->SendError("Client connections to this port are prohibited."); + return false; + } + else if (command == "CAPAB") + { + return this->Capab(params); + } + else if ((command == "U") || (command == "S")) + { + this->SendError("Cannot use the old-style mesh linking protocol with m_spanningtree.so!"); + return false; + } + else + { + irc::string error = "Invalid command in negotiation phase: " + command; + this->SendError(assign(error)); + return false; + } + break; + case WAIT_AUTH_2: + // Waiting for start of other side's netmerge to say they liked our + // password. + if (command == "SERVER") + { + // cant do this, they sent it to us in the WAIT_AUTH_1 state! + // silently ignore. + return true; + } + else if ((command == "U") || (command == "S")) + { + this->SendError("Cannot use the old-style mesh linking protocol with m_spanningtree.so!"); + return false; + } + else if (command == "BURST") + { + if (params.size() && Utils->EnableTimeSync) + { + bool we_have_delta = (Instance->Time(false) != Instance->Time(true)); + time_t them = atoi(params[0].c_str()); + time_t delta = them - Instance->Time(false); + if ((delta < -300) || (delta > 300)) + { + Instance->SNO->WriteToSnoMask('l',"\2ERROR\2: Your clocks are out by %d seconds (this is more than five minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta)); + SendError("Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than five minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!"); + return false; + } + else if ((delta < -30) || (delta > 30)) + { + Instance->SNO->WriteToSnoMask('l',"\2WARNING\2: Your clocks are out by %d seconds. Please consider synching your clocks.", abs(delta)); + } + + if (!Utils->MasterTime && !we_have_delta) + { + this->Instance->SetTimeDelta(delta); + // Send this new timestamp to any other servers + Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params); + } + } + this->LinkState = CONNECTED; + Link* lnk = Utils->FindLink(InboundServerName); + Node = new TreeServer(this->Utils,this->Instance, InboundServerName, InboundDescription, Utils->TreeRoot, this, lnk ? lnk->Hidden : false); + Utils->DelBurstingServer(this); + Utils->TreeRoot->AddChild(Node); + params.clear(); + params.push_back(InboundServerName); + params.push_back("*"); + params.push_back("1"); + params.push_back(":"+InboundDescription); + Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,InboundServerName); + this->bursting = true; + this->DoBurst(Node); + } + else if (command == "ERROR") + { + return this->Error(params); + } + else if (command == "CAPAB") + { + return this->Capab(params); + } + + break; + case LISTENER: + this->SendError("Internal error -- listening socket accepted its own descriptor!!!"); + return false; + break; + case CONNECTING: + if (command == "SERVER") + { + // another server we connected to, which was in WAIT_AUTH_1 state, + // has just sent us their credentials. If we get this far, theyre + // happy with OUR credentials, and they are now in WAIT_AUTH_2 state. + // if we're happy with this, we should send our netburst which + // kickstarts the merge. + return this->Outbound_Reply_Server(params); + } + else if (command == "ERROR") + { + return this->Error(params); + } + else if (command == "CAPAB") + { + return this->Capab(params); + } + break; + case CONNECTED: + // This is the 'authenticated' state, when all passwords + // have been exchanged and anything past this point is taken + // as gospel. + + if (!prefix.empty()) + { + std::string direction = prefix; + userrec* t = this->Instance->FindNick(prefix); + if (t) + { + direction = t->server; + } + TreeServer* route_back_again = Utils->BestRouteTo(direction); + if ((!route_back_again) || (route_back_again->GetSocket() != this)) + { + if (route_back_again) + Instance->Log(DEBUG,"Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str()); + return true; + } + /* Fix by brain: + * When there is activity on the socket, reset the ping counter so + * that we're not wasting bandwidth pinging an active server. + */ + route_back_again->SetNextPingTime(time(NULL) + 60); + route_back_again->SetPingFlag(); + } + else + { + prefix = this->GetName(); + } + + if ((command == "MODE") && (params.size() >= 2)) + { + chanrec* channel = Instance->FindChan(params[0]); + if (channel) + { + userrec* x = Instance->FindNick(prefix); + if (x) + { + if (warned.find(x->server) == warned.end()) + { + Instance->Log(DEFAULT,"WARNING: I revceived modes '%s' from another server '%s'. This is not compliant with InspIRCd. Please check that server for bugs.", params[1].c_str(), x->server); + Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending nonstandard modes: '%s MODE %s' where FMODE should be used, and may cause desyncs.", x->server, x->nick, params[1].c_str()); + warned[x->server] = x->nick; + } + } + } + } + + if (command == "SVSMODE") + { + /* Services expects us to implement + * SVSMODE. In inspircd its the same as + * MODE anyway. + */ + command = "MODE"; + } + std::string target; + /* Yes, know, this is a mess. Its reasonably fast though as we're + * working with std::string here. + */ + if ((command == "NICK") && (params.size() >= 8)) + { + return this->IntroduceClient(prefix,params); + } + else if (command == "FJOIN") + { + TreeServer* ServerSource = Utils->FindServer(prefix); + if (ServerSource) + Utils->SetRemoteBursting(ServerSource, false); + return this->ForceJoin(prefix,params); + } + else if (command == "STATS") + { + return this->Stats(prefix, params); + } + else if (command == "MOTD") + { + return this->Motd(prefix, params); + } + else if (command == "KILL" && Utils->IsServer(prefix)) + { + return this->RemoteKill(prefix,params); + } + else if (command == "MODULES") + { + return this->Modules(prefix, params); + } + else if (command == "ADMIN") + { + return this->Admin(prefix, params); + } + else if (command == "SERVER") + { + return this->RemoteServer(prefix,params); + } + else if (command == "ERROR") + { + return this->Error(params); + } + else if (command == "OPERTYPE") + { + return this->OperType(prefix,params); + } + else if (command == "FMODE") + { + TreeServer* ServerSource = Utils->FindServer(prefix); + if (ServerSource) + Utils->SetRemoteBursting(ServerSource, false); + return this->ForceMode(prefix,params); + } + else if (command == "FTOPIC") + { + return this->ForceTopic(prefix,params); + } + else if (command == "REHASH") + { + return this->RemoteRehash(prefix,params); + } + else if (command == "METADATA") + { + return this->MetaData(prefix,params); + } + else if (command == "REMSTATUS") + { + return this->RemoveStatus(prefix,params); + } + else if (command == "PING") + { + if (prefix.empty()) + prefix = this->GetName(); + /* + * We just got a ping from a server that's bursting. + * This can't be right, so set them to not bursting, and + * apply their lines. + */ + TreeServer* ServerSource = Utils->FindServer(prefix); + if (ServerSource) + Utils->SetRemoteBursting(ServerSource, false); + + if (this->bursting) + { + this->bursting = false; + Instance->XLines->apply_lines(Utils->lines_to_apply); + Utils->lines_to_apply = 0; + } + + return this->LocalPing(prefix,params); + } + else if (command == "PONG") + { + if (prefix.empty()) + prefix = this->GetName(); + /* + * We just got a pong from a server that's bursting. + * This can't be right, so set them to not bursting, and + * apply their lines. + */ + TreeServer* ServerSource = Utils->FindServer(prefix); + if (ServerSource) + Utils->SetRemoteBursting(ServerSource, false); + + if (this->bursting) + { + this->bursting = false; + Instance->XLines->apply_lines(Utils->lines_to_apply); + Utils->lines_to_apply = 0; + } + + return this->LocalPong(prefix,params); + } + else if (command == "VERSION") + { + return this->ServerVersion(prefix,params); + } + else if (command == "FHOST") + { + return this->ChangeHost(prefix,params); + } + else if (command == "FNAME") + { + return this->ChangeName(prefix,params); + } + else if (command == "ADDLINE") + { + TreeServer* ServerSource = Utils->FindServer(prefix); + if (ServerSource) + Utils->SetRemoteBursting(ServerSource, false); + return this->AddLine(prefix,params); + } + else if (command == "SVSNICK") + { + if (prefix.empty()) + { + prefix = this->GetName(); + } + return this->ForceNick(prefix,params); + } + else if (command == "OPERQUIT") + { + return this->OperQuit(prefix,params); + } + else if (command == "IDLE") + { + return this->Whois(prefix,params); + } + else if (command == "PUSH") + { + return this->Push(prefix,params); + } + else if (command == "TIMESET") + { + return this->HandleSetTime(prefix, params); + } + else if (command == "TIME") + { + return this->Time(prefix,params); + } + else if ((command == "KICK") && (Utils->IsServer(prefix))) + { + std::string sourceserv = this->myhost; + if (params.size() == 3) + { + userrec* user = this->Instance->FindNick(params[1]); + chanrec* chan = this->Instance->FindChan(params[0]); + if (user && chan) + { + if (!chan->ServerKickUser(user, params[2].c_str(), false)) + /* Yikes, the channels gone! */ + delete chan; + } + } + if (!this->InboundServerName.empty()) + { + sourceserv = this->InboundServerName; + } + return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + } + else if (command == "SVSJOIN") + { + if (prefix.empty()) + { + prefix = this->GetName(); + } + return this->ServiceJoin(prefix,params); + } + else if (command == "SQUIT") + { + if (params.size() == 2) + { + this->Squit(Utils->FindServer(params[0]),params[1]); + } + return true; + } + else if (command == "OPERNOTICE") + { + std::string sourceserv = this->myhost; + if (!this->InboundServerName.empty()) + sourceserv = this->InboundServerName; + if (params.size() >= 1) + Instance->WriteOpers("*** From " + sourceserv + ": " + params[0]); + return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); + } + else if (command == "MODENOTICE") + { + std::string sourceserv = this->myhost; + if (!this->InboundServerName.empty()) + sourceserv = this->InboundServerName; + if (params.size() >= 2) + { + Instance->WriteMode(params[0].c_str(), WM_AND, "*** From %s: %s", sourceserv.c_str(), params[1].c_str()); + } + return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); + } + else if (command == "SNONOTICE") + { + std::string sourceserv = this->myhost; + if (!this->InboundServerName.empty()) + sourceserv = this->InboundServerName; + if (params.size() >= 2) + { + Instance->SNO->WriteToSnoMask(*(params[0].c_str()), "From " + sourceserv + ": "+ params[1]); + } + return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params); + } + else if (command == "ENDBURST") + { + this->bursting = false; + Instance->XLines->apply_lines(Utils->lines_to_apply); + Utils->lines_to_apply = 0; + std::string sourceserv = this->myhost; + if (!this->InboundServerName.empty()) + sourceserv = this->InboundServerName; + this->Instance->SNO->WriteToSnoMask('l',"Received end of netburst from \2%s\2",sourceserv.c_str()); + + Event rmode((char*)sourceserv.c_str(), (Module*)Utils->Creator, "new_server"); + rmode.Send(Instance); + + return true; + } + else + { + // not a special inter-server command. + // Emulate the actual user doing the command, + // this saves us having a huge ugly parser. + userrec* who = this->Instance->FindNick(prefix); + std::string sourceserv = this->myhost; + if (!this->InboundServerName.empty()) + { + sourceserv = this->InboundServerName; + } + if ((!who) && (command == "MODE")) + { + if (Utils->IsServer(prefix)) + { + const char* modelist[127]; + for (size_t i = 0; i < params.size(); i++) + modelist[i] = params[i].c_str(); + userrec* fake = new userrec(Instance); + fake->SetFd(FD_MAGIC_NUMBER); + this->Instance->SendMode(modelist, params.size(), fake); + + delete fake; + /* Hot potato! pass it on! */ + return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + } + } + if (who) + { + if ((command == "NICK") && (params.size() > 0)) + { + /* On nick messages, check that the nick doesnt + * already exist here. If it does, kill their copy, + * and our copy. + */ + userrec* x = this->Instance->FindNick(params[0]); + if ((x) && (x != who)) + { + std::deque p; + p.push_back(params[0]); + p.push_back("Nickname collision ("+prefix+" -> "+params[0]+")"); + Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p); + p.clear(); + p.push_back(prefix); + p.push_back("Nickname collision"); + 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 Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + } + } + // its a user + target = who->server; + const char* strparams[127]; + for (unsigned int q = 0; q < params.size(); q++) + { + strparams[q] = params[q].c_str(); + } + switch (this->Instance->CallCommandHandler(command.c_str(), strparams, params.size(), who)) + { + case CMD_INVALID: + this->SendError("Unrecognised command '"+std::string(command.c_str())+"' -- possibly loaded mismatched modules"); + return false; + break; + case CMD_FAILURE: + return true; + break; + default: + /* CMD_SUCCESS and CMD_USER_DELETED fall through here */ + break; + } + } + else + { + // its not a user. Its either a server, or somethings screwed up. + if (Utils->IsServer(prefix)) + target = this->Instance->Config->ServerName; + else + return true; + } + return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params); + + } + return true; + break; + } + return true; +} + +std::string TreeSocket::GetName() +{ + std::string sourceserv = this->myhost; + if (!this->InboundServerName.empty()) + { + sourceserv = this->InboundServerName; + } + return sourceserv; +} + +void TreeSocket::OnTimeout() +{ + if (this->LinkState == CONNECTING) + { + this->Instance->SNO->WriteToSnoMask('l',"CONNECT: Connection to \002"+myhost+"\002 timed out."); + Link* MyLink = Utils->FindLink(myhost); + if (MyLink) + Utils->DoFailOver(MyLink); + } +} + +void TreeSocket::OnClose() +{ + // Connection closed. + // If the connection is fully up (state CONNECTED) + // then propogate a netsplit to all peers. + std::string quitserver = this->myhost; + if (!this->InboundServerName.empty()) + { + quitserver = this->InboundServerName; + } + TreeServer* s = Utils->FindServer(quitserver); + if (s) + { + Squit(s,"Remote host closed the connection"); + } + + if (!quitserver.empty()) + { + this->Instance->SNO->WriteToSnoMask('l',"Connection to '\2%s\2' failed.",quitserver.c_str()); + time_t server_uptime = Instance->Time() - this->age; + if (server_uptime) + Instance->SNO->WriteToSnoMask('l',"Connection to '\2%s\2' was established for %s", quitserver.c_str(), Utils->Creator->TimeToStr(server_uptime).c_str()); + } +} + +int TreeSocket::OnIncomingConnection(int newsock, char* ip) +{ + /* To prevent anyone from attempting to flood opers/DDoS by connecting to the server port, + * or discovering if this port is the server port, we don't allow connections from any + * IPs for which we don't have a link block. + */ + bool found = false; + + found = (std::find(Utils->ValidIPs.begin(), Utils->ValidIPs.end(), ip) != Utils->ValidIPs.end()); + if (!found) + { + for (vector::iterator i = Utils->ValidIPs.begin(); i != Utils->ValidIPs.end(); i++) + if (irc::sockets::MatchCIDR(ip, (*i).c_str())) + found = true; + + if (!found) + { + this->Instance->SNO->WriteToSnoMask('l',"Server connection from %s denied (no link blocks with that IP address)", ip); + close(newsock); + return false; + } + } + + TreeSocket* s = new TreeSocket(this->Utils, this->Instance, newsock, ip, this->Hook); + s = s; /* Whinge whinge whinge, thats all GCC ever does. */ + return true; +} diff --git a/src/modules/m_spanningtree/utils.cpp b/src/modules/m_spanningtree/utils.cpp index 4d0256fa2..9675a6ac8 100644 --- a/src/modules/m_spanningtree/utils.cpp +++ b/src/modules/m_spanningtree/utils.cpp @@ -1 +1,649 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "commands/cmd_whois.h" #include "commands/cmd_stats.h" #include "socket.h" #include "wildcard.h" #include "xline.h" #include "transport.h" #include "socketengine.h" #include "m_spanningtree/main.h" #include "m_spanningtree/utils.h" #include "m_spanningtree/treeserver.h" #include "m_spanningtree/link.h" #include "m_spanningtree/treesocket.h" #include "m_spanningtree/resolvers.h" /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ /** 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* SpanningTreeUtilities::FindServer(const std::string &ServerName) { server_hash::iterator iter = serverlist.find(ServerName.c_str()); if (iter != serverlist.end()) { return iter->second; } else { return NULL; } } TreeServer* SpanningTreeUtilities::FindRemoteBurstServer(TreeServer* Server) { server_hash::iterator iter = RemoteServersBursting.find(Server->GetName().c_str()); if (iter != RemoteServersBursting.end()) return iter->second; else return NULL; } TreeSocket* SpanningTreeUtilities::FindBurstingServer(const std::string &ServerName) { std::map::iterator iter; iter = burstingserverlist.find(ServerName.c_str()); if (iter != burstingserverlist.end()) { return iter->second; } else { return NULL; } } void SpanningTreeUtilities::SetRemoteBursting(TreeServer* Server, bool bursting) { server_hash::iterator iter = RemoteServersBursting.find(Server->GetName().c_str()); if (bursting) { if (iter == RemoteServersBursting.end()) RemoteServersBursting.insert(make_pair(Server->GetName(), Server)); else return; } else { if (iter != RemoteServersBursting.end()) RemoteServersBursting.erase(iter); else return; } ServerInstance->Log(DEBUG,"Server %s is %sbursting nicknames", Server->GetName().c_str(), bursting ? "" : "no longer "); } void SpanningTreeUtilities::AddBurstingServer(const std::string &ServerName, TreeSocket* s) { std::map::iterator iter = burstingserverlist.find(ServerName.c_str()); if (iter == burstingserverlist.end()) burstingserverlist[ServerName.c_str()] = s; } void SpanningTreeUtilities::DelBurstingServer(TreeSocket* s) { for (std::map::iterator iter = burstingserverlist.begin(); iter != burstingserverlist.end(); iter++) { if (iter->second == s) { burstingserverlist.erase(iter); return; } } } /** 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* SpanningTreeUtilities::BestRouteTo(const std::string &ServerName) { if (ServerName.c_str() == TreeRoot->GetName()) return NULL; TreeServer* Found = FindServer(ServerName); if (Found) { return Found->GetRoute(); } else { return NULL; } } /** 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* SpanningTreeUtilities::FindServerMask(const std::string &ServerName) { for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++) { if (match(i->first.c_str(),ServerName.c_str())) return i->second; } return NULL; } /* A convenient wrapper that returns true if a server exists */ bool SpanningTreeUtilities::IsServer(const std::string &ServerName) { return (FindServer(ServerName) != NULL); } SpanningTreeUtilities::SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* C) : ServerInstance(Instance), Creator(C) { Bindings.clear(); lines_to_apply = 0; this->TreeRoot = new TreeServer(this, ServerInstance, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc); modulelist* ml = ServerInstance->FindInterface("InspSocketHook"); /* Did we find any modules? */ if (ml) { /* Yes, enumerate them all to find out the hook name */ for (modulelist::iterator m = ml->begin(); m != ml->end(); m++) { /* Make a request to it for its name, its implementing * InspSocketHook so we know its safe to do this */ std::string name = InspSocketNameRequest((Module*)Creator, *m).Send(); /* Build a map of them */ hooks[name.c_str()] = *m; hooknames.push_back(name); } } this->ReadConfiguration(true); } SpanningTreeUtilities::~SpanningTreeUtilities() { for (unsigned int i = 0; i < Bindings.size(); i++) { ServerInstance->SE->DelFd(Bindings[i]); Bindings[i]->Close(); DELETE(Bindings[i]); } while (TreeRoot->ChildCount()) { TreeServer* child_server = TreeRoot->GetChild(0); if (child_server) { TreeSocket* sock = child_server->GetSocket(); ServerInstance->SE->DelFd(sock); sock->Close(); DELETE(sock); } } delete TreeRoot; } void SpanningTreeUtilities::AddThisServer(TreeServer* server, TreeServerList &list) { if (list.find(server) == list.end()) list[server] = server; } /* returns a list of DIRECT servernames for a specific channel */ void SpanningTreeUtilities::GetListOfServersForChannel(chanrec* c, TreeServerList &list, char status, const CUList &exempt_list) { CUList *ulist; switch (status) { case '@': ulist = c->GetOppedUsers(); break; case '%': ulist = c->GetHalfoppedUsers(); break; case '+': ulist = c->GetVoicedUsers(); break; default: ulist = c->GetUsers(); break; } for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { if ((i->first->GetFd() < 0) && (exempt_list.find(i->first) == exempt_list.end())) { TreeServer* best = this->BestRouteTo(i->first->server); if (best) AddThisServer(best,list); } } return; } bool SpanningTreeUtilities::DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, std::deque ¶ms) { char pfx = 0; TreeServer* omitroute = this->BestRouteTo(omit); if ((command == "NOTICE") || (command == "PRIVMSG")) { if (params.size() >= 2) { /* Prefixes */ if ((*(params[0].c_str()) == '@') || (*(params[0].c_str()) == '%') || (*(params[0].c_str()) == '+')) { pfx = params[0][0]; params[0] = params[0].substr(1, params[0].length()-1); } if ((*(params[0].c_str()) != '#') && (*(params[0].c_str()) != '$')) { // special routing for private messages/notices userrec* d = ServerInstance->FindNick(params[0]); if (d) { std::deque par; par.push_back(params[0]); par.push_back(":"+params[1]); this->DoOneToOne(prefix,command.c_str(),par,d->server); return true; } } else if (*(params[0].c_str()) == '$') { std::deque par; par.push_back(params[0]); par.push_back(":"+params[1]); this->DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName()); return true; } else { chanrec* c = ServerInstance->FindChan(params[0]); userrec* u = ServerInstance->FindNick(prefix); if (c && u) { CUList elist; TreeServerList list; FOREACH_MOD(I_OnBuildExemptList, OnBuildExemptList((command == "PRIVMSG" ? MSG_PRIVMSG : MSG_NOTICE), c, u, pfx, elist)); GetListOfServersForChannel(c,list,pfx,elist); for (TreeServerList::iterator i = list.begin(); i != list.end(); i++) { TreeSocket* Sock = i->second->GetSocket(); if ((Sock) && (i->second->GetName() != omit) && (omitroute != i->second)) { Sock->WriteLine(data); } } return true; } } } } unsigned int items =this->TreeRoot->ChildCount(); for (unsigned int x = 0; x < items; x++) { TreeServer* Route = this->TreeRoot->GetChild(x); if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route)) { TreeSocket* Sock = Route->GetSocket(); if (Sock) Sock->WriteLine(data); } } return true; } bool SpanningTreeUtilities::DoOneToAllButSender(const std::string &prefix, const std::string &command, std::deque ¶ms, std::string 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 = this->TreeRoot->ChildCount(); for (unsigned int x = 0; x < items; 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 // The route isnt the path to the one to be omitted if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route)) { TreeSocket* Sock = Route->GetSocket(); if (Sock) Sock->WriteLine(FullLine); } } return true; } bool SpanningTreeUtilities::DoOneToMany(const std::string &prefix, const std::string &command, std::deque ¶ms) { 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 = this->TreeRoot->ChildCount(); for (unsigned int x = 0; x < items; x++) { TreeServer* Route = this->TreeRoot->GetChild(x); if (Route && Route->GetSocket()) { TreeSocket* Sock = Route->GetSocket(); if (Sock) Sock->WriteLine(FullLine); } } return true; } bool SpanningTreeUtilities::DoOneToMany(const char* prefix, const char* command, std::deque ¶ms) { std::string spfx = prefix; std::string scmd = command; return this->DoOneToMany(spfx, scmd, params); } bool SpanningTreeUtilities::DoOneToAllButSender(const char* prefix, const char* command, std::deque ¶ms, std::string omit) { std::string spfx = prefix; std::string scmd = command; return this->DoOneToAllButSender(spfx, scmd, params, omit); } bool SpanningTreeUtilities::DoOneToOne(const std::string &prefix, const std::string &command, std::deque ¶ms, std::string target) { TreeServer* Route = this->BestRouteTo(target); if (Route) { std::string FullLine = ":" + prefix + " " + command; unsigned int words = params.size(); for (unsigned int x = 0; x < words; x++) { FullLine = FullLine + " " + params[x]; } if (Route && Route->GetSocket()) { TreeSocket* Sock = Route->GetSocket(); if (Sock) Sock->WriteLine(FullLine); } return true; } else { return false; } } void SpanningTreeUtilities::RefreshIPCache() { ValidIPs.clear(); for (std::vector::iterator L = LinkBlocks.begin(); L != LinkBlocks.end(); L++) { if ((!L->IPAddr.empty()) && (!L->RecvPass.empty()) && (!L->SendPass.empty()) && (!L->Name.empty()) && (L->Port)) { ValidIPs.push_back(L->IPAddr); if (L->AllowMask.length()) ValidIPs.push_back(L->AllowMask); /* Needs resolving */ bool ipvalid = true; QueryType start_type = DNS_QUERY_A; #ifdef IPV6 start_type = DNS_QUERY_AAAA; if (strchr(L->IPAddr.c_str(),':')) { in6_addr n; if (inet_pton(AF_INET6, L->IPAddr.c_str(), &n) < 1) ipvalid = false; } else #endif { in_addr n; if (inet_aton(L->IPAddr.c_str(),&n) < 1) ipvalid = false; } if (!ipvalid) { try { bool cached; SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L->IPAddr, *L, cached, start_type); ServerInstance->AddResolver(sr, cached); } catch (...) { } } } } } void SpanningTreeUtilities::ReadConfiguration(bool rebind) { 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); std::string Port = Conf->ReadValue("bind","port",j); std::string transport = Conf->ReadValue("bind","transport",j); if (Type == "servers") { irc::portparser portrange(Port, false); int portno = -1; while ((portno = portrange.GetToken())) { if (IP == "*") IP.clear(); if ((!transport.empty()) && (hooks.find(transport.c_str()) == hooks.end())) { ServerInstance->Log(DEFAULT,"m_spanningtree: WARNING: Can't find transport type '%s' for port %s:%s - maybe you forgot to load it BEFORE m_spanningtree in your config file? - Skipping this port binding", transport.c_str(), IP.c_str(), Port.c_str()); break; } TreeSocket* listener = new TreeSocket(this, ServerInstance, IP.c_str(), portno, true, 10, transport.empty() ? NULL : hooks[transport.c_str()]); if (listener->GetState() == I_LISTENING) { ServerInstance->Log(DEFAULT,"m_spanningtree: Binding server port %s:%d successful!", IP.c_str(), portno); Bindings.push_back(listener); } else { ServerInstance->Log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port: %s:%d: %s",IP.c_str(), portno, strerror(errno)); listener->Close(); DELETE(listener); } } } } } FlatLinks = Conf->ReadFlag("options","flatlinks",0); HideULines = Conf->ReadFlag("options","hideulines",0); AnnounceTSChange = Conf->ReadFlag("options","announcets",0); EnableTimeSync = Conf->ReadFlag("timesync","enable",0); MasterTime = Conf->ReadFlag("timesync", "master", 0); ChallengeResponse = !Conf->ReadFlag("options", "disablehmac", 0); quiet_bursts = Conf->ReadFlag("options", "quietbursts", 0); PingWarnTime = Conf->ReadInteger("options", "pingwarning", 0, true); if (PingWarnTime < 0 || PingWarnTime > 59) PingWarnTime = 0; LinkBlocks.clear(); ValidIPs.clear(); for (int j = 0; j < Conf->Enumerate("link"); j++) { Link L; std::string Allow = Conf->ReadValue("link", "allowmask", j); L.Name = (Conf->ReadValue("link", "name", j)).c_str(); L.AllowMask = Allow; L.IPAddr = Conf->ReadValue("link", "ipaddr", j); L.FailOver = Conf->ReadValue("link", "failover", j).c_str(); L.Port = Conf->ReadInteger("link", "port", j, true); L.SendPass = Conf->ReadValue("link", "sendpass", j); L.RecvPass = Conf->ReadValue("link", "recvpass", j); L.AutoConnect = Conf->ReadInteger("link", "autoconnect", j, true); L.HiddenFromStats = Conf->ReadFlag("link", "statshidden", j); L.Timeout = Conf->ReadInteger("link", "timeout", j, true); L.Hook = Conf->ReadValue("link", "transport", j); L.Bind = Conf->ReadValue("link", "bind", j); L.Hidden = Conf->ReadFlag("link", "hidden", j); if ((!L.Hook.empty()) && (hooks.find(L.Hook.c_str()) == hooks.end())) { ServerInstance->Log(DEFAULT,"m_spanningtree: WARNING: Can't find transport type '%s' for link '%s' - maybe you forgot to load it BEFORE m_spanningtree in your config file? Skipping tag completely.", L.Hook.c_str(), L.Name.c_str()); continue; } L.NextConnectTime = time(NULL) + L.AutoConnect; /* Bugfix by brain, do not allow people to enter bad configurations */ if (L.Name != ServerInstance->Config->ServerName) { if ((!L.IPAddr.empty()) && (!L.RecvPass.empty()) && (!L.SendPass.empty()) && (!L.Name.empty()) && (L.Port)) { ValidIPs.push_back(L.IPAddr); if (Allow.length()) ValidIPs.push_back(Allow); /* Needs resolving */ bool ipvalid = true; QueryType start_type = DNS_QUERY_A; #ifdef IPV6 start_type = DNS_QUERY_AAAA; if (strchr(L.IPAddr.c_str(),':')) { in6_addr n; if (inet_pton(AF_INET6, L.IPAddr.c_str(), &n) < 1) ipvalid = false; } else { in_addr n; if (inet_aton(L.IPAddr.c_str(),&n) < 1) ipvalid = false; } #else in_addr n; if (inet_aton(L.IPAddr.c_str(),&n) < 1) ipvalid = false; #endif if (!ipvalid) { try { bool cached; SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L.IPAddr, L, cached, start_type); ServerInstance->AddResolver(sr, cached); } catch (...) { } } LinkBlocks.push_back(L); } else { if (L.IPAddr.empty()) { ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', IP address not defined!",L.Name.c_str()); } else if (L.RecvPass.empty()) { ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', recvpass not defined!",L.Name.c_str()); } else if (L.SendPass.empty()) { ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', sendpass not defined!",L.Name.c_str()); } else if (L.Name.empty()) { ServerInstance->Log(DEFAULT,"Invalid configuration, link tag without a name!"); } else if (!L.Port) { ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', no port specified!",L.Name.c_str()); } } } else { ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', link tag has the same server name as the local server!",L.Name.c_str()); } } DELETE(Conf); } void SpanningTreeUtilities::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()); 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* SpanningTreeUtilities::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; } \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "commands/cmd_whois.h" +#include "commands/cmd_stats.h" +#include "socket.h" +#include "wildcard.h" +#include "xline.h" +#include "transport.h" +#include "socketengine.h" + +#include "m_spanningtree/main.h" +#include "m_spanningtree/utils.h" +#include "m_spanningtree/treeserver.h" +#include "m_spanningtree/link.h" +#include "m_spanningtree/treesocket.h" +#include "m_spanningtree/resolvers.h" + +/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */ + +/** 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* SpanningTreeUtilities::FindServer(const std::string &ServerName) +{ + server_hash::iterator iter = serverlist.find(ServerName.c_str()); + if (iter != serverlist.end()) + { + return iter->second; + } + else + { + return NULL; + } +} + +TreeServer* SpanningTreeUtilities::FindRemoteBurstServer(TreeServer* Server) +{ + server_hash::iterator iter = RemoteServersBursting.find(Server->GetName().c_str()); + if (iter != RemoteServersBursting.end()) + return iter->second; + else + return NULL; +} + +TreeSocket* SpanningTreeUtilities::FindBurstingServer(const std::string &ServerName) +{ + std::map::iterator iter; + iter = burstingserverlist.find(ServerName.c_str()); + if (iter != burstingserverlist.end()) + { + return iter->second; + } + else + { + return NULL; + } +} + +void SpanningTreeUtilities::SetRemoteBursting(TreeServer* Server, bool bursting) +{ + server_hash::iterator iter = RemoteServersBursting.find(Server->GetName().c_str()); + if (bursting) + { + if (iter == RemoteServersBursting.end()) + RemoteServersBursting.insert(make_pair(Server->GetName(), Server)); + else return; + } + else + { + if (iter != RemoteServersBursting.end()) + RemoteServersBursting.erase(iter); + else return; + } + ServerInstance->Log(DEBUG,"Server %s is %sbursting nicknames", Server->GetName().c_str(), bursting ? "" : "no longer "); +} + +void SpanningTreeUtilities::AddBurstingServer(const std::string &ServerName, TreeSocket* s) +{ + std::map::iterator iter = burstingserverlist.find(ServerName.c_str()); + if (iter == burstingserverlist.end()) + burstingserverlist[ServerName.c_str()] = s; +} + +void SpanningTreeUtilities::DelBurstingServer(TreeSocket* s) +{ + for (std::map::iterator iter = burstingserverlist.begin(); iter != burstingserverlist.end(); iter++) + { + if (iter->second == s) + { + burstingserverlist.erase(iter); + return; + } + } +} + +/** 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* SpanningTreeUtilities::BestRouteTo(const std::string &ServerName) +{ + if (ServerName.c_str() == TreeRoot->GetName()) + return NULL; + TreeServer* Found = FindServer(ServerName); + if (Found) + { + return Found->GetRoute(); + } + else + { + return NULL; + } +} + +/** 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* SpanningTreeUtilities::FindServerMask(const std::string &ServerName) +{ + for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++) + { + if (match(i->first.c_str(),ServerName.c_str())) + return i->second; + } + return NULL; +} + +/* A convenient wrapper that returns true if a server exists */ +bool SpanningTreeUtilities::IsServer(const std::string &ServerName) +{ + return (FindServer(ServerName) != NULL); +} + +SpanningTreeUtilities::SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* C) : ServerInstance(Instance), Creator(C) +{ + Bindings.clear(); + + lines_to_apply = 0; + + this->TreeRoot = new TreeServer(this, ServerInstance, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc); + + modulelist* ml = ServerInstance->FindInterface("InspSocketHook"); + + /* Did we find any modules? */ + if (ml) + { + /* Yes, enumerate them all to find out the hook name */ + for (modulelist::iterator m = ml->begin(); m != ml->end(); m++) + { + /* Make a request to it for its name, its implementing + * InspSocketHook so we know its safe to do this + */ + std::string name = InspSocketNameRequest((Module*)Creator, *m).Send(); + /* Build a map of them */ + hooks[name.c_str()] = *m; + hooknames.push_back(name); + } + } + + this->ReadConfiguration(true); +} + +SpanningTreeUtilities::~SpanningTreeUtilities() +{ + for (unsigned int i = 0; i < Bindings.size(); i++) + { + ServerInstance->SE->DelFd(Bindings[i]); + Bindings[i]->Close(); + DELETE(Bindings[i]); + } + while (TreeRoot->ChildCount()) + { + TreeServer* child_server = TreeRoot->GetChild(0); + if (child_server) + { + TreeSocket* sock = child_server->GetSocket(); + ServerInstance->SE->DelFd(sock); + sock->Close(); + DELETE(sock); + } + } + delete TreeRoot; +} + +void SpanningTreeUtilities::AddThisServer(TreeServer* server, TreeServerList &list) +{ + if (list.find(server) == list.end()) + list[server] = server; +} + +/* returns a list of DIRECT servernames for a specific channel */ +void SpanningTreeUtilities::GetListOfServersForChannel(chanrec* c, TreeServerList &list, char status, const CUList &exempt_list) +{ + CUList *ulist; + switch (status) + { + case '@': + ulist = c->GetOppedUsers(); + break; + case '%': + ulist = c->GetHalfoppedUsers(); + break; + case '+': + ulist = c->GetVoicedUsers(); + break; + default: + ulist = c->GetUsers(); + break; + } + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + { + if ((i->first->GetFd() < 0) && (exempt_list.find(i->first) == exempt_list.end())) + { + TreeServer* best = this->BestRouteTo(i->first->server); + if (best) + AddThisServer(best,list); + } + } + return; +} + +bool SpanningTreeUtilities::DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, std::deque ¶ms) +{ + char pfx = 0; + TreeServer* omitroute = this->BestRouteTo(omit); + if ((command == "NOTICE") || (command == "PRIVMSG")) + { + if (params.size() >= 2) + { + /* Prefixes */ + if ((*(params[0].c_str()) == '@') || (*(params[0].c_str()) == '%') || (*(params[0].c_str()) == '+')) + { + pfx = params[0][0]; + params[0] = params[0].substr(1, params[0].length()-1); + } + if ((*(params[0].c_str()) != '#') && (*(params[0].c_str()) != '$')) + { + // special routing for private messages/notices + userrec* d = ServerInstance->FindNick(params[0]); + if (d) + { + std::deque par; + par.push_back(params[0]); + par.push_back(":"+params[1]); + this->DoOneToOne(prefix,command.c_str(),par,d->server); + return true; + } + } + else if (*(params[0].c_str()) == '$') + { + std::deque par; + par.push_back(params[0]); + par.push_back(":"+params[1]); + this->DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName()); + return true; + } + else + { + chanrec* c = ServerInstance->FindChan(params[0]); + userrec* u = ServerInstance->FindNick(prefix); + if (c && u) + { + CUList elist; + TreeServerList list; + FOREACH_MOD(I_OnBuildExemptList, OnBuildExemptList((command == "PRIVMSG" ? MSG_PRIVMSG : MSG_NOTICE), c, u, pfx, elist)); + GetListOfServersForChannel(c,list,pfx,elist); + + for (TreeServerList::iterator i = list.begin(); i != list.end(); i++) + { + TreeSocket* Sock = i->second->GetSocket(); + if ((Sock) && (i->second->GetName() != omit) && (omitroute != i->second)) + { + Sock->WriteLine(data); + } + } + return true; + } + } + } + } + unsigned int items =this->TreeRoot->ChildCount(); + for (unsigned int x = 0; x < items; x++) + { + TreeServer* Route = this->TreeRoot->GetChild(x); + if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route)) + { + TreeSocket* Sock = Route->GetSocket(); + if (Sock) + Sock->WriteLine(data); + } + } + return true; +} + +bool SpanningTreeUtilities::DoOneToAllButSender(const std::string &prefix, const std::string &command, std::deque ¶ms, std::string 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 = this->TreeRoot->ChildCount(); + for (unsigned int x = 0; x < items; 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 + // The route isnt the path to the one to be omitted + if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route)) + { + TreeSocket* Sock = Route->GetSocket(); + if (Sock) + Sock->WriteLine(FullLine); + } + } + return true; +} + +bool SpanningTreeUtilities::DoOneToMany(const std::string &prefix, const std::string &command, std::deque ¶ms) +{ + 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 = this->TreeRoot->ChildCount(); + for (unsigned int x = 0; x < items; x++) + { + TreeServer* Route = this->TreeRoot->GetChild(x); + if (Route && Route->GetSocket()) + { + TreeSocket* Sock = Route->GetSocket(); + if (Sock) + Sock->WriteLine(FullLine); + } + } + return true; +} + +bool SpanningTreeUtilities::DoOneToMany(const char* prefix, const char* command, std::deque ¶ms) +{ + std::string spfx = prefix; + std::string scmd = command; + return this->DoOneToMany(spfx, scmd, params); +} + +bool SpanningTreeUtilities::DoOneToAllButSender(const char* prefix, const char* command, std::deque ¶ms, std::string omit) +{ + std::string spfx = prefix; + std::string scmd = command; + return this->DoOneToAllButSender(spfx, scmd, params, omit); +} + +bool SpanningTreeUtilities::DoOneToOne(const std::string &prefix, const std::string &command, std::deque ¶ms, std::string target) +{ + TreeServer* Route = this->BestRouteTo(target); + if (Route) + { + std::string FullLine = ":" + prefix + " " + command; + unsigned int words = params.size(); + for (unsigned int x = 0; x < words; x++) + { + FullLine = FullLine + " " + params[x]; + } + if (Route && Route->GetSocket()) + { + TreeSocket* Sock = Route->GetSocket(); + if (Sock) + Sock->WriteLine(FullLine); + } + return true; + } + else + { + return false; + } +} + +void SpanningTreeUtilities::RefreshIPCache() +{ + ValidIPs.clear(); + for (std::vector::iterator L = LinkBlocks.begin(); L != LinkBlocks.end(); L++) + { + if ((!L->IPAddr.empty()) && (!L->RecvPass.empty()) && (!L->SendPass.empty()) && (!L->Name.empty()) && (L->Port)) + { + ValidIPs.push_back(L->IPAddr); + + if (L->AllowMask.length()) + ValidIPs.push_back(L->AllowMask); + + /* Needs resolving */ + bool ipvalid = true; + QueryType start_type = DNS_QUERY_A; +#ifdef IPV6 + start_type = DNS_QUERY_AAAA; + if (strchr(L->IPAddr.c_str(),':')) + { + in6_addr n; + if (inet_pton(AF_INET6, L->IPAddr.c_str(), &n) < 1) + ipvalid = false; + } + else +#endif + { + in_addr n; + if (inet_aton(L->IPAddr.c_str(),&n) < 1) + ipvalid = false; + } + if (!ipvalid) + { + try + { + bool cached; + SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L->IPAddr, *L, cached, start_type); + ServerInstance->AddResolver(sr, cached); + } + catch (...) + { + } + } + } + } +} + +void SpanningTreeUtilities::ReadConfiguration(bool rebind) +{ + 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); + std::string Port = Conf->ReadValue("bind","port",j); + std::string transport = Conf->ReadValue("bind","transport",j); + if (Type == "servers") + { + irc::portparser portrange(Port, false); + int portno = -1; + while ((portno = portrange.GetToken())) + { + if (IP == "*") + IP.clear(); + + if ((!transport.empty()) && (hooks.find(transport.c_str()) == hooks.end())) + { + ServerInstance->Log(DEFAULT,"m_spanningtree: WARNING: Can't find transport type '%s' for port %s:%s - maybe you forgot to load it BEFORE m_spanningtree in your config file? - Skipping this port binding", transport.c_str(), IP.c_str(), Port.c_str()); + break; + } + + TreeSocket* listener = new TreeSocket(this, ServerInstance, IP.c_str(), portno, true, 10, transport.empty() ? NULL : hooks[transport.c_str()]); + if (listener->GetState() == I_LISTENING) + { + ServerInstance->Log(DEFAULT,"m_spanningtree: Binding server port %s:%d successful!", IP.c_str(), portno); + Bindings.push_back(listener); + } + else + { + ServerInstance->Log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port: %s:%d: %s",IP.c_str(), portno, strerror(errno)); + listener->Close(); + DELETE(listener); + } + } + } + } + } + FlatLinks = Conf->ReadFlag("options","flatlinks",0); + HideULines = Conf->ReadFlag("options","hideulines",0); + AnnounceTSChange = Conf->ReadFlag("options","announcets",0); + EnableTimeSync = Conf->ReadFlag("timesync","enable",0); + MasterTime = Conf->ReadFlag("timesync", "master", 0); + ChallengeResponse = !Conf->ReadFlag("options", "disablehmac", 0); + quiet_bursts = Conf->ReadFlag("options", "quietbursts", 0); + PingWarnTime = Conf->ReadInteger("options", "pingwarning", 0, true); + + if (PingWarnTime < 0 || PingWarnTime > 59) + PingWarnTime = 0; + + LinkBlocks.clear(); + ValidIPs.clear(); + for (int j = 0; j < Conf->Enumerate("link"); j++) + { + Link L; + std::string Allow = Conf->ReadValue("link", "allowmask", j); + L.Name = (Conf->ReadValue("link", "name", j)).c_str(); + L.AllowMask = Allow; + L.IPAddr = Conf->ReadValue("link", "ipaddr", j); + L.FailOver = Conf->ReadValue("link", "failover", j).c_str(); + L.Port = Conf->ReadInteger("link", "port", j, true); + L.SendPass = Conf->ReadValue("link", "sendpass", j); + L.RecvPass = Conf->ReadValue("link", "recvpass", j); + L.AutoConnect = Conf->ReadInteger("link", "autoconnect", j, true); + L.HiddenFromStats = Conf->ReadFlag("link", "statshidden", j); + L.Timeout = Conf->ReadInteger("link", "timeout", j, true); + L.Hook = Conf->ReadValue("link", "transport", j); + L.Bind = Conf->ReadValue("link", "bind", j); + L.Hidden = Conf->ReadFlag("link", "hidden", j); + + if ((!L.Hook.empty()) && (hooks.find(L.Hook.c_str()) == hooks.end())) + { + ServerInstance->Log(DEFAULT,"m_spanningtree: WARNING: Can't find transport type '%s' for link '%s' - maybe you forgot to load it BEFORE m_spanningtree in your config file? Skipping tag completely.", + L.Hook.c_str(), L.Name.c_str()); + continue; + + } + + L.NextConnectTime = time(NULL) + L.AutoConnect; + /* Bugfix by brain, do not allow people to enter bad configurations */ + if (L.Name != ServerInstance->Config->ServerName) + { + if ((!L.IPAddr.empty()) && (!L.RecvPass.empty()) && (!L.SendPass.empty()) && (!L.Name.empty()) && (L.Port)) + { + ValidIPs.push_back(L.IPAddr); + + if (Allow.length()) + ValidIPs.push_back(Allow); + + /* Needs resolving */ + bool ipvalid = true; + QueryType start_type = DNS_QUERY_A; +#ifdef IPV6 + start_type = DNS_QUERY_AAAA; + if (strchr(L.IPAddr.c_str(),':')) + { + in6_addr n; + if (inet_pton(AF_INET6, L.IPAddr.c_str(), &n) < 1) + ipvalid = false; + } + else + { + in_addr n; + if (inet_aton(L.IPAddr.c_str(),&n) < 1) + ipvalid = false; + } +#else + in_addr n; + if (inet_aton(L.IPAddr.c_str(),&n) < 1) + ipvalid = false; +#endif + + if (!ipvalid) + { + try + { + bool cached; + SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L.IPAddr, L, cached, start_type); + ServerInstance->AddResolver(sr, cached); + } + catch (...) + { + } + } + + LinkBlocks.push_back(L); + } + else + { + if (L.IPAddr.empty()) + { + ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', IP address not defined!",L.Name.c_str()); + } + else if (L.RecvPass.empty()) + { + ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', recvpass not defined!",L.Name.c_str()); + } + else if (L.SendPass.empty()) + { + ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', sendpass not defined!",L.Name.c_str()); + } + else if (L.Name.empty()) + { + ServerInstance->Log(DEFAULT,"Invalid configuration, link tag without a name!"); + } + else if (!L.Port) + { + ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', no port specified!",L.Name.c_str()); + } + } + } + else + { + ServerInstance->Log(DEFAULT,"Invalid configuration for server '%s', link tag has the same server name as the local server!",L.Name.c_str()); + } + } + DELETE(Conf); +} + +void SpanningTreeUtilities::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()); + 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* SpanningTreeUtilities::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; +} + diff --git a/src/modules/m_spanningtree/utils.h b/src/modules/m_spanningtree/utils.h index 48146e89e..cb783a81a 100644 --- a/src/modules/m_spanningtree/utils.h +++ b/src/modules/m_spanningtree/utils.h @@ -1 +1,194 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #ifndef __ST__UTIL__ #define __ST__UTIL__ #include "configreader.h" #include "users.h" #include "channels.h" #include "modules.h" #include "inspircd.h" /* Foward declarations */ class TreeServer; class TreeSocket; class Link; class ModuleSpanningTree; /* This hash_map holds the hash equivalent of the server * tree, used for rapid linear lookups. */ #ifdef WINDOWS typedef nspace::hash_map > > server_hash; #else typedef nspace::hash_map, irc::StrHashComp> server_hash; #endif typedef std::map TreeServerList; /** A group of modules that implement InspSocketHook * that we can use to hook our server to server connections. */ typedef std::map hookmodules; /** 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; /** Remote servers that are currently bursting */ server_hash RemoteServersBursting; /** 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; /** Synchronize timestamps between servers */ bool EnableTimeSync; /** Make snomasks +CQ quiet during bursts and splits */ bool quiet_bursts; /** Socket bindings for listening sockets */ std::vector Bindings; /* Number of seconds that a server can go without ping * before opers are warned of high latency. */ int PingWarnTime; /** 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; /** Hash of servers currently bursting but not initialized as connected */ std::map burstingserverlist; /** Holds the data from the tags in the conf */ std::vector LinkBlocks; /** Holds a bitmask of queued xline types waiting to be applied. * Will be a mask containing values APPLY_GLINES, APPLY_KLINES, * APPLY_QLINES and APPLY_ZLINES. */ int lines_to_apply; /** If this is true, this server is the master sync server for time * synching - e.g. it is the server with its clock correct. It will * send out the correct time at intervals. */ bool MasterTime; /** List of module pointers which can provide I/O abstraction */ hookmodules hooks; /** List of module names which can provide I/O abstraction */ std::vector hooknames; /** True (default) if we are to use challenge-response HMAC * to authenticate passwords. * * NOTE: This defaults to on, but should be turned off if * you are linking to an older version of inspircd. */ bool ChallengeResponse; /** 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(const std::string &prefix, const 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(const std::string &prefix, const 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(const std::string &prefix, const 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(const std::string &data, const std::string &omit, const std::string &prefix, const 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, TreeServerList &list); /** Compile a list of servers which contain members of channel c */ void GetListOfServersForChannel(chanrec* c, TreeServerList &list, char status, const CUList &exempt_list); /** Find a server by name */ TreeServer* FindServer(const std::string &ServerName); /** Find a remote bursting server by name */ TreeServer* FindRemoteBurstServer(TreeServer* Server); /** Set a remote server to bursting or not bursting */ void SetRemoteBursting(TreeServer* Server, bool bursting); /** Find a route to a server by name */ TreeServer* BestRouteTo(const std::string &ServerName); /** Find a server by glob mask */ TreeServer* FindServerMask(const std::string &ServerName); /** Returns true if this is a server name we recognise */ bool IsServer(const 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); /** Refresh the IP cache used for allowing inbound connections */ void RefreshIPCache(); TreeSocket* FindBurstingServer(const std::string &ServerName); void AddBurstingServer(const std::string &ServerName, TreeSocket* s); void DelBurstingServer(TreeSocket* s); }; #endif \ No newline at end of file +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __ST__UTIL__ +#define __ST__UTIL__ + +#include "configreader.h" +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "inspircd.h" + +/* Foward declarations */ +class TreeServer; +class TreeSocket; +class Link; +class ModuleSpanningTree; + +/* This hash_map holds the hash equivalent of the server + * tree, used for rapid linear lookups. + */ +#ifdef WINDOWS +typedef nspace::hash_map > > server_hash; +#else +typedef nspace::hash_map, irc::StrHashComp> server_hash; +#endif + +typedef std::map TreeServerList; + +/** A group of modules that implement InspSocketHook + * that we can use to hook our server to server connections. + */ +typedef std::map hookmodules; + +/** 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; + /** Remote servers that are currently bursting + */ + server_hash RemoteServersBursting; + /** 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; + /** Synchronize timestamps between servers + */ + bool EnableTimeSync; + /** Make snomasks +CQ quiet during bursts and splits + */ + bool quiet_bursts; + /** Socket bindings for listening sockets + */ + std::vector Bindings; + /* Number of seconds that a server can go without ping + * before opers are warned of high latency. + */ + int PingWarnTime; + /** 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; + /** Hash of servers currently bursting but not initialized as connected + */ + std::map burstingserverlist; + /** Holds the data from the tags in the conf + */ + std::vector LinkBlocks; + /** Holds a bitmask of queued xline types waiting to be applied. + * Will be a mask containing values APPLY_GLINES, APPLY_KLINES, + * APPLY_QLINES and APPLY_ZLINES. + */ + int lines_to_apply; + + /** If this is true, this server is the master sync server for time + * synching - e.g. it is the server with its clock correct. It will + * send out the correct time at intervals. + */ + bool MasterTime; + + /** List of module pointers which can provide I/O abstraction + */ + hookmodules hooks; + + /** List of module names which can provide I/O abstraction + */ + std::vector hooknames; + + /** True (default) if we are to use challenge-response HMAC + * to authenticate passwords. + * + * NOTE: This defaults to on, but should be turned off if + * you are linking to an older version of inspircd. + */ + bool ChallengeResponse; + + /** 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(const std::string &prefix, const 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(const std::string &prefix, const 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(const std::string &prefix, const 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(const std::string &data, const std::string &omit, const std::string &prefix, const 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, TreeServerList &list); + /** Compile a list of servers which contain members of channel c + */ + void GetListOfServersForChannel(chanrec* c, TreeServerList &list, char status, const CUList &exempt_list); + /** Find a server by name + */ + TreeServer* FindServer(const std::string &ServerName); + /** Find a remote bursting server by name + */ + TreeServer* FindRemoteBurstServer(TreeServer* Server); + /** Set a remote server to bursting or not bursting + */ + void SetRemoteBursting(TreeServer* Server, bool bursting); + /** Find a route to a server by name + */ + TreeServer* BestRouteTo(const std::string &ServerName); + /** Find a server by glob mask + */ + TreeServer* FindServerMask(const std::string &ServerName); + /** Returns true if this is a server name we recognise + */ + bool IsServer(const 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); + /** Refresh the IP cache used for allowing inbound connections + */ + void RefreshIPCache(); + + TreeSocket* FindBurstingServer(const std::string &ServerName); + + void AddBurstingServer(const std::string &ServerName, TreeSocket* s); + + void DelBurstingServer(TreeSocket* s); +}; + +#endif -- cgit v1.2.3