X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmodules%2Fm_spanningtree%2Fmain.cpp;h=5613251b08ddcb94f7d5dcf48fd45daea7064e1b;hb=8e14d91fb92768ea4fe838cd4a0ec335b7b735df;hp=af827fa96fd7cdbdf25f73ee6e9e28c1661d5802;hpb=bf65e9dc25b9e52dc1f84a6e24157bdaf8d39d5c;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp index af827fa96..5613251b0 100644 --- a/src/modules/m_spanningtree/main.cpp +++ b/src/modules/m_spanningtree/main.cpp @@ -6,13 +6,14 @@ * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see - * the file COPYING for details. + * 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" @@ -20,138 +21,31 @@ #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/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" -/** Handle /RCONNECT - */ -class cmd_rconnect : public command_t -{ - Module* Creator; - SpanningTreeUtilities* Utils; - public: - 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 Handle (const char** parameters, int pcnt, userrec *user) - { - if (IS_LOCAL(user)) - { - if (!Utils->FindServer(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; - } -}; - -/** 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; - public: - ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, cached, me), MyLink(x), Utils(Util) - { - /* Nothing in here, folks */ - } - - void 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.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 OnError(ResolverError e, const std::string &errormessage) - { - /* Ooops! */ - 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); - } -}; - -/** 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); -}; - +/* $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"); 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); @@ -159,6 +53,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) @@ -170,7 +67,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) { @@ -183,9 +80,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() @@ -233,21 +137,48 @@ 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; } +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)+"ms]"); +} + // 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) +void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][128], float &totusers, float &totservers) { if (line < 128) { @@ -267,7 +198,10 @@ void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, spacer[5] = '\0'; } float percent; - char text[80]; + 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; @@ -276,14 +210,15 @@ void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, { 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); + 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,80); + strlcpy(&matrix[line][depth],text,126); line++; 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) { @@ -302,6 +237,9 @@ int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* u { 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]); @@ -309,12 +247,11 @@ int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* u 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; @@ -324,6 +261,9 @@ int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec* { 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]); @@ -331,12 +271,33 @@ int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec* 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; @@ -346,11 +307,15 @@ int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, userrec* { 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) { @@ -359,7 +324,7 @@ int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, userrec* } else { - user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]); + user->WriteServ( "402 %s %s :No such server", user->nick, parameters[1]); } return 1; } @@ -381,7 +346,7 @@ void ModuleSpanningTree::HandleMap(const char** parameters, int pcnt, userrec* u // client does not provide for a proper terminal. float totusers = 0; float totservers = 0; - char matrix[128][80]; + char matrix[128][128]; for (unsigned int t = 0; t < 128; t++) { matrix[t][0] = '\0'; @@ -447,15 +412,11 @@ int ModuleSpanningTree::HandleSquit(const char** parameters, int pcnt, userrec* 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]); + if (IS_LOCAL(user)) + user->WriteServ("NOTICE %s :*** WARNING: Using SQUIT to split remote servers is deprecated. Please use RSQUIT instead.",user->nick); } } else @@ -524,41 +485,76 @@ void ModuleSpanningTree::DoPingChecks(time_t curtime) if (serv->AnsweredLastPing()) { sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName()); - serv->SetNextPingTime(curtime + 60); + 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) { - insp_inaddr binip; + 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 (insp_aton(x->IPAddr.c_str(), &binip) > 0) + 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->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]); + 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; + 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); } } @@ -567,12 +563,12 @@ void ModuleSpanningTree::ConnectServer(Link* x) try { bool cached; - ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, 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()); + RemoteMessage(NULL, "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason()); Utils->DoFailOver(x); } } @@ -627,6 +623,45 @@ 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, ...) +{ + 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->ServerName, "SNONOTICE", params); + } + else + { + if (IS_LOCAL(user)) + user->WriteServ("NOTICE %s :%s", user->nick, text); + else + { + params.push_back(user->nick); + params.push_back(std::string("::") + ServerInstance->Config->ServerName + " NOTICE " + user->nick + " :*** From " + + ServerInstance->Config->ServerName+ ": " + text); + Utils->DoOneToMany(ServerInstance->Config->ServerName, "PUSH", params); + } + } +} int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec* user) { @@ -637,26 +672,30 @@ 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)",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()); + RemoteMessage(user, "*** 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]); + RemoteMessage(user, "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() { - std::deque params; - params.push_back(ConvToStr(ServerInstance->Time(true))); - Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params); + 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) @@ -670,9 +709,28 @@ int ModuleSpanningTree::OnStats(char statschar, userrec* user, string_list &resu results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+Utils->LinkBlocks[i].Name.c_str()); } results.push_back(std::string(ServerInstance->Config->ServerName)+" 219 "+user->nick+" "+statschar+" :End of /STATS report"); - ServerInstance->SNO->WriteToSnoMask('t',"Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host); + 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; } @@ -681,6 +739,7 @@ int ModuleSpanningTree::OnPreCommand(const std::string &command, const char** pa /* 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); @@ -733,6 +792,10 @@ int ModuleSpanningTree::OnPreCommand(const std::string &command, const char** pa this->HandleVersion(parameters,pcnt,user); return 1; } + else if ((command == "MODULES") && (pcnt > 0)) + { + return this->HandleModules(parameters,pcnt,user); + } return 0; } @@ -904,7 +967,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)) @@ -921,8 +984,7 @@ void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel) Utils->DoOneToMany(ServerInstance->Config->ServerName,"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"); + params.push_back(channel->ChanModes(true)); Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params); } else @@ -955,13 +1017,13 @@ void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos) Utils->DoOneToMany(user->nick,"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); } @@ -992,11 +1054,18 @@ void ModuleSpanningTree::OnUserConnect(userrec* user) } } -void ModuleSpanningTree::OnUserQuit(userrec* user, const std::string &reason) +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); } @@ -1018,7 +1087,7 @@ void ModuleSpanningTree::OnUserPostNick(userrec* user, const std::string &oldnic } } -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))) { @@ -1038,17 +1107,21 @@ void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* cha } } -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(":"+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 != "") + if (!parameter.empty()) { std::deque params; params.push_back(parameter); @@ -1160,22 +1233,25 @@ 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; + 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); + command = "MODE"; } else { chanrec* c = (chanrec*)dest; - std::deque params; params.push_back(c->name); + params.push_back(ConvToStr(c->age)); params.push_back(text); - Utils->DoOneToMany(user->nick,"MODE",params); + command = "FMODE"; } + Utils->DoOneToMany(user->nick, command, params); } } @@ -1268,6 +1344,8 @@ void ModuleSpanningTree::OnEvent(Event* event) if (a) { ourTS = a->age; + Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params); + return; } else { @@ -1275,10 +1353,10 @@ void ModuleSpanningTree::OnEvent(Event* event) if (a) { ourTS = a->age; + params->insert(params->begin() + 1,ConvToStr(ourTS)); + Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params); } } - params->insert(params->begin() + 1,ConvToStr(ourTS)); - Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params); } else if (event->GetEventID() == "send_mode_explicit") { @@ -1329,6 +1407,8 @@ ModuleSpanningTree::~ModuleSpanningTree() if (SyncTimer) ServerInstance->Timers->DelTimer(SyncTimer); + ServerInstance->Timers->DelTimer(RefreshTimer); + ServerInstance->DoneWithInterface("InspSocketHook"); } @@ -1360,36 +1440,5 @@ Priority ModuleSpanningTree::Prioritize() return PRIORITY_LAST; } -TimeSyncTimer::TimeSyncTimer(InspIRCd *Inst, ModuleSpanningTree *Mod) : InspTimer(43200, Inst->Time(), true), Instance(Inst), Module(Mod) -{ -} +MODULE_INIT(ModuleSpanningTree) -void TimeSyncTimer::Tick(time_t TIME) -{ - Module->BroadcastTimeSync(); -} - - -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; -}