X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Fmain.cpp;h=4a31d70076412e7ed1942a7bc05e55ddf0c0199d;hb=f087d825a88760d251b8f80b5d50bc98b40fa2ae;hp=1fd33b946be551e18a4234047a7d2785b08f2362;hpb=5bbc794c7db6363e8f43b69a6f19307dfc411a04;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp index 1fd33b946..4a31d7007 100644 --- a/src/modules/m_spanningtree/main.cpp +++ b/src/modules/m_spanningtree/main.cpp @@ -13,14 +13,10 @@ /* $ModDesc: Provides a spanning tree server link protocol */ -#include "configreader.h" -#include "users.h" -#include "channels.h" -#include "modules.h" +#include "inspircd.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" @@ -33,16 +29,19 @@ #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 */ +/* $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::Module(Me), max_local(0), max_global(0) + : Module(Me), max_local(0), max_global(0) { - ServerInstance->UseInterface("InspSocketHook"); + ServerInstance->Modules->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); @@ -50,6 +49,9 @@ ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me) } else SyncTimer = NULL; + + RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils); + ServerInstance->Timers->AddTimer(RefreshTimer); } void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops) @@ -61,7 +63,7 @@ void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops) } for (unsigned int q = 0; q < Current->ChildCount(); q++) { - if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str()))) + if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))) { if (*user->oper) { @@ -74,9 +76,16 @@ void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops) } } /* 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())) && (!*user->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 && (!*user->oper)) ? ServerInstance->Config->ServerName : Parent.c_str(),(Utils->FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str()); + + user->WriteServ("364 %s %s %s :%d %s", user->nick,Current->GetName().c_str(), + (Utils->FlatLinks && (!IS_OPER(user))) ? ServerInstance->Config->ServerName : Parent.c_str(), + (Utils->FlatLinks && (!IS_OPER(user))) ? 0 : hops, + Current->GetDesc().c_str()); } int ModuleSpanningTree::CountLocalServs() @@ -124,282 +133,38 @@ void ModuleSpanningTree::HandleLusers(const char** parameters, int pcnt, userrec } } } - 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()); + 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("254 %s :I have %d clients and %d servers",user->nick,ServerInstance->LocalUserCount(),ulined_local_count ? this->CountLocalServs() - ulined_local_count : this->CountLocalServs()); + + 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; } -// WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS. -void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80], 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[80]; - 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; - } - snprintf(text, 80, "%s %s%5d [%5.2f%%]", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent); - totusers += Current->GetUserCount(); - totservers++; - strlcpy(&matrix[line][depth],text,80); - line++; - for (unsigned int q = 0; q < Current->ChildCount(); q++) - { - if ((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) - { - /* 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) - { - 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) +std::string ModuleSpanningTree::TimeToStr(time_t secs) { - if (pcnt > 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) - { - 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::HandleStats(const char** parameters, int pcnt, userrec* user) -{ - if (pcnt > 1) - { - /* 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[0]); - } - 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][80]; - 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(); - delete sock; - } - else - { - /* route it */ - std::deque params; - params.push_back(parameters[0]); - params.push_back(std::string(":Server quit by ") + user->GetFullRealHost()); - Utils->DoOneToOne(user->nick, "RSQUIT", params, parameters[0]); - } - } - 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; + 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"); } void ModuleSpanningTree::DoPingChecks(time_t curtime) @@ -414,22 +179,39 @@ void ModuleSpanningTree::DoPingChecks(time_t curtime) { if (serv->AnsweredLastPing()) { - sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName()); - serv->SetNextPingTime(curtime + 60); + sock->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" PING "+serv->GetID()); + serv->SetNextPingTime(curtime + Utils->PingFreq); + serv->LastPing = curtime; + timeval t; + gettimeofday(&t, NULL); + long ts = (t.tv_sec * 1000) + (t.tv_usec / 1000); + serv->LastPingMsec = ts; + serv->Warned = false; } else { - // they didnt answer, boot them - ServerInstance->SNO->WriteToSnoMask('l',"Server \002%s\002 pinged out",serv->GetName().c_str()); + /* they didnt answer, boot them */ + sock->SendError("Ping timeout"); sock->Squit(serv,"Ping timeout"); ServerInstance->SE->DelFd(sock); sock->Close(); - delete sock; return; } } + else if ((Utils->PingWarnTime) && (!serv->Warned) && (curtime >= serv->NextPingTime() - (Utils->PingFreq - 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) @@ -445,16 +227,12 @@ void ModuleSpanningTree::ConnectServer(Link* x) ipvalid = false; } else +#endif { in_addr n; if (inet_aton(x->IPAddr.c_str(),&n) < 1) ipvalid = false; } -#else - in_addr n; - if (inet_aton(x->IPAddr.c_str(),&n) < 1) - ipvalid = false; -#endif /* Do we already have an IP? If so, no need to resolve it. */ if (ipvalid) @@ -469,8 +247,9 @@ void ModuleSpanningTree::ConnectServer(Link* x) } else { - ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno)); - delete newsocket; + RemoteMessage(NULL, "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno)); + if (ServerInstance->SocketCull.find(newsocket) == ServerInstance->SocketCull.end()) + ServerInstance->SocketCull[newsocket] = newsocket; Utils->DoFailOver(x); } } @@ -484,7 +263,7 @@ void ModuleSpanningTree::ConnectServer(Link* x) } catch (ModuleException& e) { - ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason()); + RemoteMessage(NULL, "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason()); Utils->DoFailOver(x); } } @@ -539,6 +318,56 @@ int ModuleSpanningTree::HandleVersion(const char** parameters, int pcnt, userrec } return 1; } + +/* This method will attempt to get a link message out to as many people as is required. + * If a user is provided, and that user is local, then the user is sent the message using + * WriteServ (they are the local initiator of that message). If the user is remote, they are + * sent that message remotely via PUSH. + * If the user is NULL, then the notice is sent locally via WriteToSnoMask with snomask 'l', + * and remotely via SNONOTICE with mask 'l'. + */ +void ModuleSpanningTree::RemoteMessage(userrec* user, const char* format, ...) +{ + /* This could cause an infinite loop, because DoOneToMany() will, on error, + * call TreeSocket::OnError(), which in turn will call this function to + * notify everyone of the error. So, drop any messages that are generated + * during the sending of another message. -Special */ + static bool SendingRemoteMessage = false; + if (SendingRemoteMessage) + return; + SendingRemoteMessage = true; + + std::deque params; + char text[MAXBUF]; + va_list argsPtr; + + va_start(argsPtr, format); + vsnprintf(text, MAXBUF, format, argsPtr); + va_end(argsPtr); + + if (!user) + { + /* No user, target it generically at everyone */ + ServerInstance->SNO->WriteToSnoMask('l', "%s", text); + params.push_back("l"); + params.push_back(std::string(":") + text); + Utils->DoOneToMany(ServerInstance->Config->GetSID(), "SNONOTICE", params); + } + else + { + if (IS_LOCAL(user)) + user->WriteServ("NOTICE %s :%s", user->nick, text); + else + { + params.push_back(user->uuid); + params.push_back(std::string("::") + ServerInstance->Config->ServerName + " NOTICE " + user->nick + " :*** From " + + ServerInstance->Config->ServerName+ ": " + text); + Utils->DoOneToMany(ServerInstance->Config->GetSID(), "PUSH", params); + } + } + + SendingRemoteMessage = false; +} int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec* user) { @@ -549,18 +378,18 @@ int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec 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); + RemoteMessage(user, "*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",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()); + RemoteMessage(user, "*** CONNECT: Server \002%s\002 already exists on the network and is connected via \002%s\002",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]); + RemoteMessage(user, "*** CONNECT: No server matching \002%s\002 could be found in the config file.",parameters[0]); return 1; } @@ -571,110 +400,7 @@ void ModuleSpanningTree::BroadcastTimeSync() 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; - } - 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; - } - 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); + Utils->DoOneToMany(ServerInstance->Config->GetSID(), "TIMESET", params); } } @@ -692,9 +418,9 @@ void ModuleSpanningTree::OnUserInvite(userrec* source,userrec* dest,chanrec* cha if (IS_LOCAL(source)) { std::deque params; - params.push_back(dest->nick); + params.push_back(dest->uuid); params.push_back(channel->name); - Utils->DoOneToMany(source->nick,"INVITE",params); + Utils->DoOneToMany(source->uuid,"INVITE",params); } } @@ -703,7 +429,7 @@ void ModuleSpanningTree::OnPostLocalTopicChange(userrec* user, chanrec* chan, co std::deque params; params.push_back(chan->name); params.push_back(":"+topic); - Utils->DoOneToMany(user->nick,"TOPIC",params); + Utils->DoOneToMany(user->uuid,"TOPIC",params); } void ModuleSpanningTree::OnWallops(userrec* user, const std::string &text) @@ -712,7 +438,7 @@ void ModuleSpanningTree::OnWallops(userrec* user, const std::string &text) { std::deque params; params.push_back(":"+text); - Utils->DoOneToMany(user->nick,"WALLOPS",params); + Utils->DoOneToMany(user->uuid,"WALLOPS",params); } } @@ -725,9 +451,9 @@ void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type { std::deque params; params.clear(); - params.push_back(d->nick); + params.push_back(d->uuid); params.push_back(":"+text); - Utils->DoOneToOne(user->nick,"NOTICE",params,d->server); + Utils->DoOneToOne(user->uuid,"NOTICE",params,d->server); } } else if (target_type == TYPE_CHANNEL) @@ -746,7 +472,7 @@ void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type { TreeSocket* Sock = i->second->GetSocket(); if (Sock) - Sock->WriteLine(":"+std::string(user->nick)+" NOTICE "+cname+" :"+text); + Sock->WriteLine(":"+std::string(user->uuid)+" NOTICE "+cname+" :"+text); } } } @@ -759,7 +485,7 @@ void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type std::deque par; par.push_back(target); par.push_back(":"+text); - Utils->DoOneToMany(user->nick,"NOTICE",par); + Utils->DoOneToMany(user->uuid,"NOTICE",par); } } } @@ -775,9 +501,9 @@ void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_typ { std::deque params; params.clear(); - params.push_back(d->nick); + params.push_back(d->uuid); params.push_back(":"+text); - Utils->DoOneToOne(user->nick,"PRIVMSG",params,d->server); + Utils->DoOneToOne(user->uuid,"PRIVMSG",params,d->server); } } else if (target_type == TYPE_CHANNEL) @@ -796,7 +522,7 @@ void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_typ { TreeSocket* Sock = i->second->GetSocket(); if (Sock) - Sock->WriteLine(":"+std::string(user->nick)+" PRIVMSG "+cname+" :"+text); + Sock->WriteLine(":"+std::string(user->uuid)+" PRIVMSG "+cname+" :"+text); } } } @@ -809,7 +535,7 @@ void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_typ std::deque par; par.push_back(target); par.push_back(":"+text); - Utils->DoOneToMany(user->nick,"PRIVMSG",par); + Utils->DoOneToMany(user->uuid,"PRIVMSG",par); } } } @@ -820,7 +546,7 @@ void ModuleSpanningTree::OnBackgroundTimer(time_t curtime) DoPingChecks(curtime); } -void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel) +void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel, bool &silent) { // Only do this for local users if (IS_LOCAL(user)) @@ -833,20 +559,19 @@ void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel) // 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); + params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->uuid)); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FJOIN",params); /* First user in, sync the modes for the channel */ params.pop_back(); - /* This is safe, all inspircd servers default to +nt */ - params.push_back("+nt"); - Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params); + params.push_back(channel->ChanModes(true)); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",params); } else { std::deque params; params.push_back(channel->name); params.push_back(ConvToStr(channel->age)); - Utils->DoOneToMany(user->nick,"JOIN",params); + Utils->DoOneToMany(user->uuid,"JOIN",params); } } } @@ -858,7 +583,7 @@ void ModuleSpanningTree::OnChangeHost(userrec* user, const std::string &newhost) return; std::deque params; params.push_back(newhost); - Utils->DoOneToMany(user->nick,"FHOST",params); + Utils->DoOneToMany(user->uuid,"FHOST",params); } void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos) @@ -868,37 +593,37 @@ void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos) return; std::deque params; params.push_back(gecos); - Utils->DoOneToMany(user->nick,"FNAME",params); + Utils->DoOneToMany(user->uuid,"FNAME",params); } -void ModuleSpanningTree::OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage) +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 != "") + if (!partmessage.empty()) params.push_back(":"+partmessage); - Utils->DoOneToMany(user->nick,"PART",params); + Utils->DoOneToMany(user->uuid,"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->uuid); + params.push_back(ConvToStr(user->age)); 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(ConvToStr(user->signon)); params.push_back(":"+std::string(user->fullname)); - Utils->DoOneToMany(ServerInstance->Config->ServerName,"NICK",params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(), "UID", params); // User is Local, change needs to be reflected! TreeServer* SourceServer = Utils->FindServer(user->server); if (SourceServer) @@ -917,11 +642,11 @@ void ModuleSpanningTree::OnUserQuit(userrec* user, const std::string &reason, co if (oper_message != reason) { params.push_back(":"+oper_message); - Utils->DoOneToMany(user->nick,"OPERQUIT",params); + Utils->DoOneToMany(user->uuid,"OPERQUIT",params); } params.clear(); params.push_back(":"+reason); - Utils->DoOneToMany(user->nick,"QUIT",params); + Utils->DoOneToMany(user->uuid,"QUIT",params); } // Regardless, We need to modify the user Counts.. TreeServer* SourceServer = Utils->FindServer(user->server); @@ -937,45 +662,56 @@ void ModuleSpanningTree::OnUserPostNick(userrec* user, const std::string &oldnic { std::deque params; params.push_back(user->nick); - Utils->DoOneToMany(oldnick,"NICK",params); + + /** IMPORTANT: We don't update the TS if the oldnick is just a case change of the newnick! + */ + if (irc::string(user->nick) != assign(oldnick)) + user->age = ServerInstance->Time(true); + + params.push_back(ConvToStr(user->age)); + Utils->DoOneToMany(user->uuid,"NICK",params); } } -void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason) +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(user->uuid); params.push_back(":"+reason); - Utils->DoOneToMany(source->nick,"KICK",params); + Utils->DoOneToMany(source->uuid,"KICK",params); } else if (!source) { std::deque params; params.push_back(chan->name); - params.push_back(user->nick); + params.push_back(user->uuid); params.push_back(":"+reason); - Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"KICK",params); } } -void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason) +void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason, const std::string &operreason) { std::deque params; - params.push_back(dest->nick); params.push_back(":"+reason); - Utils->DoOneToMany(source->nick,"KILL",params); + Utils->DoOneToMany(dest->uuid,"OPERQUIT",params); + params.clear(); + params.push_back(dest->uuid); + params.push_back(":"+reason); + dest->SetOperQuit(operreason); + Utils->DoOneToMany(source->uuid,"KILL",params); } void ModuleSpanningTree::OnRehash(userrec* user, const std::string ¶meter) { - if (parameter != "") + if (!parameter.empty()) { std::deque params; params.push_back(parameter); - Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->ServerName, "REHASH", params); + Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->GetSID(), "REHASH", params); // check for self if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter)) { @@ -996,7 +732,7 @@ void ModuleSpanningTree::OnOper(userrec* user, const std::string &opertype) { std::deque params; params.push_back(opertype); - Utils->DoOneToMany(user->nick,"OPERTYPE",params); + Utils->DoOneToMany(user->uuid,"OPERTYPE",params); } } @@ -1010,7 +746,7 @@ void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool a (unsigned long)duration, reason.c_str()); std::deque params; params.push_back(data); - Utils->DoOneToMany(ServerInstance->Config->ServerName, "ADDLINE", params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(), "ADDLINE", params); } else { @@ -1027,13 +763,13 @@ void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool a params.push_back(host); params.push_back(sduration); params.push_back(":"+reason); - Utils->DoOneToMany(source->nick,stype,params); + Utils->DoOneToMany(source->uuid,stype,params); } else { std::deque params; params.push_back(host); - Utils->DoOneToMany(source->nick,stype,params); + Utils->DoOneToMany(source->uuid,stype,params); } } } @@ -1083,22 +819,29 @@ void ModuleSpanningTree::OnMode(userrec* user, void* dest, int target_type, cons { if ((IS_LOCAL(user)) && (user->registered == REG_ALL)) { + std::deque params; + std::string command; + std::string output_text; + + ServerInstance->Parser->TranslateUIDs(TR_SPACENICKLIST, text, output_text); + if (target_type == TYPE_USER) { userrec* u = (userrec*)dest; - std::deque params; - params.push_back(u->nick); - params.push_back(text); - Utils->DoOneToMany(user->nick,"MODE",params); + params.push_back(u->uuid); + params.push_back(output_text); + command = "MODE"; } else { chanrec* c = (chanrec*)dest; - std::deque params; params.push_back(c->name); - params.push_back(text); - Utils->DoOneToMany(user->nick,"MODE",params); + params.push_back(ConvToStr(c->age)); + params.push_back(output_text); + command = "FMODE"; } + + Utils->DoOneToMany(user->uuid, command, params); } } @@ -1108,7 +851,7 @@ void ModuleSpanningTree::OnSetAway(userrec* user) { std::deque params; params.push_back(":"+std::string(user->awaymsg)); - Utils->DoOneToMany(user->nick,"AWAY",params); + Utils->DoOneToMany(user->uuid,"AWAY",params); } } @@ -1118,24 +861,28 @@ void ModuleSpanningTree::OnCancelAway(userrec* user) { std::deque params; params.clear(); - Utils->DoOneToMany(user->nick,"AWAY",params); + Utils->DoOneToMany(user->uuid,"AWAY",params); } } void ModuleSpanningTree::ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline) { TreeSocket* s = (TreeSocket*)opaque; + std::string output_text; + + ServerInstance->Parser->TranslateUIDs(TR_SPACENICKLIST, modeline, output_text); + if (target) { if (target_type == TYPE_USER) { userrec* u = (userrec*)target; - s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline); + s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" FMODE "+u->uuid+" "+ConvToStr(u->age)+" "+output_text); } else { chanrec* c = (chanrec*)target; - s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline); + s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+output_text); } } } @@ -1148,17 +895,17 @@ void ModuleSpanningTree::ProtoSendMetaData(void* opaque, int target_type, void* if (target_type == TYPE_USER) { userrec* u = (userrec*)target; - s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+u->nick+" "+extname+" :"+extdata); + s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+u->uuid+" "+extname+" :"+extdata); } else if (target_type == TYPE_CHANNEL) { chanrec* c = (chanrec*)target; - s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+c->name+" "+extname+" :"+extdata); + s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+c->name+" "+extname+" :"+extdata); } } if (target_type == TYPE_OTHER) { - s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA * "+extname+" :"+extdata); + s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA * "+extname+" :"+extdata); } } @@ -1170,7 +917,7 @@ void ModuleSpanningTree::OnEvent(Event* event) if (params->size() < 3) return; (*params)[2] = ":" + (*params)[2]; - Utils->DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"METADATA",*params); } else if (event->GetEventID() == "send_topic") { @@ -1179,7 +926,7 @@ void ModuleSpanningTree::OnEvent(Event* event) (*params)[1] = ":" + (*params)[1]; params->insert(params->begin() + 1,ServerInstance->Config->ServerName); params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time(true))); - Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FTOPIC",*params); } else if (event->GetEventID() == "send_mode") { @@ -1187,10 +934,18 @@ void ModuleSpanningTree::OnEvent(Event* event) return; // Insert the TS value of the object, either userrec or chanrec time_t ourTS = 0; + std::string output_text; + + /* Warning: in-place translation is only safe for type TR_NICK */ + for (size_t n = 0; n < params->size(); n++) + ServerInstance->Parser->TranslateUIDs(TR_NICK, (*params)[n], (*params)[n]); + userrec* a = ServerInstance->FindNick((*params)[0]); if (a) { ourTS = a->age; + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",*params); + return; } else { @@ -1198,37 +953,43 @@ void ModuleSpanningTree::OnEvent(Event* event) if (a) { ourTS = a->age; + params->insert(params->begin() + 1,ConvToStr(ourTS)); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",*params); } } - 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); + std::string output_text; + + /* Warning: in-place translation is only safe for type TR_NICK */ + for (size_t n = 0; n < params->size(); n++) + ServerInstance->Parser->TranslateUIDs(TR_NICK, (*params)[n], (*params)[n]); + + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",*params); } else if (event->GetEventID() == "send_opers") { if (params->size() < 1) return; (*params)[0] = ":" + (*params)[0]; - Utils->DoOneToMany(ServerInstance->Config->ServerName,"OPERNOTICE",*params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"OPERNOTICE",*params); } else if (event->GetEventID() == "send_modeset") { if (params->size() < 2) return; (*params)[1] = ":" + (*params)[1]; - Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODENOTICE",*params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODENOTICE",*params); } else if (event->GetEventID() == "send_snoset") { if (params->size() < 2) return; (*params)[1] = ":" + (*params)[1]; - Utils->DoOneToMany(ServerInstance->Config->ServerName,"SNONOTICE",*params); + Utils->DoOneToMany(ServerInstance->Config->GetSID(),"SNONOTICE",*params); } else if (event->GetEventID() == "send_push") { @@ -1239,9 +1000,10 @@ void ModuleSpanningTree::OnEvent(Event* event) if (!a) return; - + + (*params)[0] = a->uuid; (*params)[1] = ":" + (*params)[1]; - Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", *params, a->server); + Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PUSH", *params, a->server); } } @@ -1252,7 +1014,9 @@ ModuleSpanningTree::~ModuleSpanningTree() if (SyncTimer) ServerInstance->Timers->DelTimer(SyncTimer); - ServerInstance->DoneWithInterface("InspSocketHook"); + ServerInstance->Timers->DelTimer(RefreshTimer); + + ServerInstance->Modules->DoneWithInterface("InspSocketHook"); } Version ModuleSpanningTree::GetVersion() @@ -1283,26 +1047,4 @@ Priority ModuleSpanningTree::Prioritize() return PRIORITY_LAST; } -class ModuleSpanningTreeFactory : public ModuleFactory -{ - public: - ModuleSpanningTreeFactory() - { - } - - ~ModuleSpanningTreeFactory() - { - } - - virtual Module * CreateModule(InspIRCd* Me) - { - return new ModuleSpanningTree(Me); - } - -}; - - -extern "C" void * init_module( void ) -{ - return new ModuleSpanningTreeFactory; -} +MODULE_INIT(ModuleSpanningTree)