/* $ModDesc: Provides a spanning tree server link protocol */
#include "inspircd.h"
-#include "commands/cmd_whois.h"
-#include "commands/cmd_stats.h"
#include "socket.h"
#include "xline.h"
#include "../transport.h"
/* $ModDep: m_spanningtree/cachetimer.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 m_spanningtree/protocolinterface.h */
-ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me)
- : Module(Me), max_local(0), max_global(0)
+ModuleSpanningTree::ModuleSpanningTree()
+ : max_local(0), max_global(0)
{
ServerInstance->Modules->UseInterface("BufferedSocketHook");
- Utils = new SpanningTreeUtilities(ServerInstance, this);
- command_rconnect = new CommandRConnect(ServerInstance, this, Utils);
+ Utils = new SpanningTreeUtilities(this);
+ command_rconnect = new CommandRConnect(this, Utils);
ServerInstance->AddCommand(command_rconnect);
- command_rsquit = new CommandRSQuit(ServerInstance, this, Utils);
+ command_rsquit = new CommandRSQuit(this, Utils);
ServerInstance->AddCommand(command_rsquit);
- RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils);
+ RefreshTimer = new CacheRefreshTimer(Utils);
ServerInstance->Timers->AddTimer(RefreshTimer);
Implementation eventlist[] =
{
- I_OnPreCommand, I_OnGetServerDescription, I_OnUserInvite, I_OnPostLocalTopicChange,
+ I_OnPreCommand, I_OnGetServerDescription, I_OnUserInvite, I_OnPostTopicChange,
I_OnWallops, I_OnUserNotice, I_OnUserMessage, I_OnBackgroundTimer, I_OnUserJoin,
I_OnChangeLocalUserHost, I_OnChangeName, I_OnChangeIdent, I_OnUserPart, I_OnUnloadModule,
I_OnUserQuit, I_OnUserPostNick, I_OnUserKick, I_OnRemoteKill, I_OnRehash, I_OnPreRehash,
ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
delete ServerInstance->PI;
- ServerInstance->PI = new SpanningTreeProtocolInterface(this, Utils, ServerInstance);
+ ServerInstance->PI = new SpanningTreeProtocolInterface(this, Utils);
loopCall = false;
// update our local user count
}
}
-void ModuleSpanningTree::ConnectServer(Link* x)
+void ModuleSpanningTree::ConnectServer(Link* x, Autoconnect* y)
{
bool ipvalid = true;
if (InspIRCd::Match(ServerInstance->Config->ServerName, assign(x->Name)))
{
- this->ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Not connecting to myself.");
+ ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Not connecting to myself.");
return;
}
/* 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, x->Timeout ? x->Timeout : 10,x->Name.c_str(), x->Bind, x->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]);
+ TreeSocket* newsocket = new TreeSocket(Utils, x->IPAddr,x->Port, x->Timeout ? x->Timeout : 10,x->Name.c_str(), x->Bind, y, x->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]);
if (newsocket->GetFd() > -1)
{
/* Handled automatically on success */
}
else
{
- this->ServerInstance->SNO->WriteToSnoMask('l', "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);
+ ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
+ ServerInstance->GlobalCulls.AddItem(newsocket);
+ Utils->DoFailOver(y);
}
}
else
try
{
bool cached;
- ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached, start_type);
+ ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, x->IPAddr, *x, cached, start_type, y);
ServerInstance->AddResolver(snr, cached);
}
catch (ModuleException& e)
{
- this->ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
- Utils->DoFailOver(x);
+ ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
+ Utils->DoFailOver(y);
}
}
}
void ModuleSpanningTree::AutoConnectServers(time_t curtime)
{
- for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
+ for (std::vector<Autoconnect>::iterator x = Utils->AutoconnectBlocks.begin(); x < Utils->AutoconnectBlocks.end(); ++x)
{
- if ((x->AutoConnect) && (curtime >= x->NextConnectTime))
+ if (curtime >= x->NextConnectTime)
{
- x->NextConnectTime = curtime + x->AutoConnect;
- TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
+ x->NextConnectTime = curtime + x->Period;
+ TreeServer* CheckDupe = Utils->FindServer(x->Server.c_str());
+ Link* y = Utils->FindLink(x->Server);
if (x->FailOver.length())
{
TreeServer* CheckFailOver = Utils->FindServer(x->FailOver.c_str());
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));
+ ServerInstance->SNO->WriteToSnoMask('l',"AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",y->Name.c_str(),x->Period);
+ this->ConnectServer(&(*y), &(*x));
}
}
}
void ModuleSpanningTree::DoConnectTimeout(time_t curtime)
{
- std::vector<Link*> failovers;
+ std::vector<Autoconnect*> failovers;
for (std::map<TreeSocket*, std::pair<std::string, int> >::iterator i = Utils->timeoutlist.begin(); i != Utils->timeoutlist.end(); i++)
{
TreeSocket* s = i->first;
if (curtime > s->age + p.second)
{
ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002 (timeout of %d seconds)",p.first.c_str(),p.second);
+ failovers.push_back(s->myautoconnect);
ServerInstance->SE->DelFd(s);
s->Close();
- Link* MyLink = Utils->FindLink(p.first);
- if (MyLink)
- failovers.push_back(MyLink);
}
}
/* Trigger failover for each timed out socket */
- for (std::vector<Link*>::const_iterator n = failovers.begin(); n != failovers.end(); ++n)
+ for (std::vector<Autoconnect*>::const_iterator n = failovers.begin(); n != failovers.end(); ++n)
{
Utils->DoFailOver(*n);
}
if (!CheckDupe)
{
RemoteMessage(user, "*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",x->Name.c_str(),(x->HiddenFromStats ? "<hidden>" : x->IPAddr.c_str()),x->Port);
- ConnectServer(&(*x));
+ ConnectServer(&(*x), NULL);
return MOD_RES_DENY;
}
else
}
}
-void ModuleSpanningTree::OnPostLocalTopicChange(User* user, Channel* chan, const std::string &topic)
+void ModuleSpanningTree::OnPostTopicChange(User* user, Channel* chan, const std::string &topic)
{
+ // Drop remote events on the floor.
+ if (!IS_LOCAL(user))
+ return;
+
parameterlist params;
params.push_back(chan->name);
params.push_back(":"+topic);
Utils->TreeRoot->SetUserCount(1); // increment by 1
}
-void ModuleSpanningTree::OnUserJoin(User* user, Channel* channel, bool sync, bool &silent, bool created)
+void ModuleSpanningTree::OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts)
{
// Only do this for local users
- if (IS_LOCAL(user))
+ if (IS_LOCAL(memb->user))
{
parameterlist 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->ChanModes(true));
- params.push_back(ServerInstance->Modes->ModeString(user, channel, false)+","+std::string(user->uuid));
+ params.push_back(memb->chan->name);
+ params.push_back(ConvToStr(memb->chan->age));
+ params.push_back(std::string("+") + memb->chan->ChanModes(true));
+ params.push_back(memb->modes+","+std::string(memb->user->uuid));
Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FJOIN",params);
}
}
Utils->DoOneToMany(user->uuid,"FIDENT",params);
}
-void ModuleSpanningTree::OnUserPart(User* user, Channel* channel, std::string &partmessage, bool &silent)
+void ModuleSpanningTree::OnUserPart(Membership* memb, std::string &partmessage, CUList& excepts)
{
- if (IS_LOCAL(user))
+ if (IS_LOCAL(memb->user))
{
parameterlist params;
- params.push_back(channel->name);
+ params.push_back(memb->chan->name);
if (!partmessage.empty())
params.push_back(":"+partmessage);
- Utils->DoOneToMany(user->uuid,"PART",params);
+ Utils->DoOneToMany(memb->user->uuid,"PART",params);
}
}
params.push_back(ConvToStr(user->age));
Utils->DoOneToMany(user->uuid,"NICK",params);
}
+ else if (!loopCall && user->nick == user->uuid)
+ {
+ parameterlist params;
+ params.push_back(user->uuid);
+ params.push_back(ConvToStr(user->age));
+ Utils->DoOneToMany(ServerInstance->Config->GetSID(),"SAVE",params);
+ }
}
-void ModuleSpanningTree::OnUserKick(User* source, User* user, Channel* chan, const std::string &reason, bool &silent)
+void ModuleSpanningTree::OnUserKick(User* source, Membership* memb, const std::string &reason, CUList& excepts)
{
parameterlist params;
- params.push_back(chan->name);
- params.push_back(user->uuid);
+ params.push_back(memb->chan->name);
+ params.push_back(memb->user->uuid);
params.push_back(":"+reason);
if (IS_LOCAL(source))
{
Utils->DoOneToMany(source->uuid,"KICK",params);
}
- else if (IS_FAKE(source) && source != Utils->ServerUser)
+ else if (IS_SERVER(source) && source != Utils->ServerUser)
{
Utils->DoOneToMany(ServerInstance->Config->GetSID(),"KICK",params);
}
if (!IS_LOCAL(source))
return; // Only start routing if we're origin.
- dest->Extend("operquit", new std::string(operreason));
+ User::OperQuit.set(dest, operreason);
parameterlist params;
params.push_back(":"+operreason);
Utils->DoOneToMany(dest->uuid,"OPERQUIT",params);
if (awaymsg.empty())
{
parameterlist params;
- params.clear();
Utils->DoOneToMany(user->uuid,"AWAY",params);
}
else
{
parameterlist params;
+ params.push_back(ConvToStr(user->awaytime));
params.push_back(":" + awaymsg);
Utils->DoOneToMany(user->uuid,"AWAY",params);
}
s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA * "+extname+" :"+extdata);
}
-std::string ModuleSpanningTree::ProtoTranslate(Extensible* item)
-{
- User* u = dynamic_cast<User*>(item);
- Channel* c = dynamic_cast<Channel*>(item);
- if (u)
- return u->uuid;
- if (c)
- return c->name;
- return "*";
-}
-
void ModuleSpanningTree::OnEvent(Event* event)
{
if ((event->GetEventID() == "send_encap") || (event->GetEventID() == "send_metadata") || (event->GetEventID() == "send_topic") || (event->GetEventID() == "send_mode") || (event->GetEventID() == "send_mode_explicit") || (event->GetEventID() == "send_opers")
}
}
+bool ModuleSpanningTree::cull()
+{
+ return Utils->cull();
+}
+
ModuleSpanningTree::~ModuleSpanningTree()
{
delete ServerInstance->PI;
- ServerInstance->PI = new ProtocolInterface(ServerInstance);
+ ServerInstance->PI = new ProtocolInterface;
/* This will also free the listeners */
delete Utils;
Version ModuleSpanningTree::GetVersion()
{
- return Version("$Id$", VF_VENDOR, API_VERSION);
+ return Version("Allows servers to be linked", VF_VENDOR);
}
/* It is IMPORTANT that m_spanningtree is the last module in the chain
projects / user / henk / code / inspircd.git / blobdiff