* 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"
#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"
-/** 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 = "<remote-server-mask> <target-server-mask>";
- }
-
- 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 */
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);
}
else
SyncTimer = NULL;
+
+ RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils);
+ ServerInstance->Timers->AddTimer(RefreshTimer);
}
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)
{
}
}
/* 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;
- 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());
+ /* 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()
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)+"s]");
+}
+
// 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)
{
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;
{
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)
{
{
if (pcnt > 0)
{
+ if (match(ServerInstance->Config->ServerName, parameters[0]))
+ return 0;
+
/* Remote MOTD, the server is within the 1st parameter */
std::deque<std::string> 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;
{
if (pcnt > 0)
{
+ if (match(ServerInstance->Config->ServerName, parameters[0]))
+ return 1;
+
/* Remote ADMIN, the server is within the 1st parameter */
std::deque<std::string> 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::HandleModules(const char** parameters, int pcnt, userrec* user)
+{
+ if (match(ServerInstance->Config->ServerName, parameters[0]))
+ return 1;
+
+ std::deque<std::string> params;
+ params.push_back(parameters[0]);
+ TreeServer* s = Utils->FindServerMask(parameters[0]);
+ if (s)
+ Utils->DoOneToOne(user->nick, "MODULES", params, s->GetName());
+ else
+ user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
+ return 1;
+}
+
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<std::string> 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)
{
}
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;
}
// 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';
{
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
- 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();
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)
{
- 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
+ {
+ 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 (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 */
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)
void ModuleSpanningTree::BroadcastTimeSync()
{
- std::deque<std::string> params;
- params.push_back(ConvToStr(ServerInstance->Time(true)));
- Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
+ if (Utils->MasterTime)
+ {
+ std::deque<std::string> 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)
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;
}
return 0;
/* 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);
this->HandleVersion(parameters,pcnt,user);
return 1;
}
+ else if ((command == "MODULES") && (pcnt > 0))
+ {
+ return this->HandleModules(parameters,pcnt,user);
+ }
return 0;
}
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))
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());
Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params);
}
else
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))
{
}
}
-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<std::string> 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);
}
}
}
-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)))
{
{
if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
{
+ std::deque<std::string> params;
+ std::string command;
+
if (target_type == TYPE_USER)
{
userrec* u = (userrec*)dest;
- std::deque<std::string> 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<std::string> 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);
}
}
if (a)
{
ourTS = a->age;
+ Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params);
+ return;
}
else
{
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")
{
if (SyncTimer)
ServerInstance->Timers->DelTimer(SyncTimer);
+ ServerInstance->Timers->DelTimer(RefreshTimer);
+
ServerInstance->DoneWithInterface("InspSocketHook");
}
return PRIORITY_LAST;
}
-TimeSyncTimer::TimeSyncTimer(InspIRCd *Inst, ModuleSpanningTree *Mod) : InspTimer(43200, Inst->Time(), true), Instance(Inst), Module(Mod)
-{
-}
-
-void TimeSyncTimer::Tick(time_t TIME)
-{
- Module->BroadcastTimeSync();
-}
-
-
class ModuleSpanningTreeFactory : public ModuleFactory
{
public:
};
-extern "C" void * init_module( void )
+extern "C" DllExport void * init_module( void )
{
return new ModuleSpanningTreeFactory;
}
projects / user / henk / code / inspircd.git / blobdiff