void ModuleSpanningTree::DoPingChecks(time_t curtime)
{
/*
* Cancel remote burst mode on any servers which still have it enabled due to latency/lack of data.
* This prevents lost REMOTECONNECT notices
*/
long ts = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000);
restart:
for (server_hash::iterator i = Utils->serverlist.begin(); i != Utils->serverlist.end(); i++)
{
TreeServer *s = i->second;
// Skip myself
if (s->IsRoot())
continue;
// Do not ping servers that are not fully connected yet!
// Servers which are connected to us have IsLocal() == true and if they're fully connected
// then Socket->LinkState == CONNECTED. Servers that are linked to another server are always fully connected.
if (s->IsLocal() && s->GetSocket()->GetLinkState() != CONNECTED)
continue;
// Now do PING checks on all servers
// Only ping if this server needs one
if (curtime >= s->NextPingTime())
{
// And if they answered the last
if (s->AnsweredLastPing())
{
// They did, send a ping to them
s->SetNextPingTime(curtime + Utils->PingFreq);
s->GetSocket()->WriteLine(CmdBuilder("PING").push(s->GetID()));
s->LastPingMsec = ts;
}
else
{
// They didn't answer the last ping, if they are locally connected, get rid of them.
if (s->IsLocal())
{
TreeSocket* sock = s->GetSocket();
sock->SendError("Ping timeout");
sock->Close();
goto restart;
}
}
}
// If warn on ping enabled and not warned and the difference is sufficient and they didn't answer the last ping...
if ((Utils->PingWarnTime) && (!s->Warned) && (curtime >= s->NextPingTime() - (Utils->PingFreq - Utils->PingWarnTime)) && (!s->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.", s->GetName().c_str(), Utils->PingWarnTime);
s->Warned = true;
}
}
}
ModResult ModuleSpanningTree::HandleSquit(const std::vector<std::string>& parameters, User* user)
{
TreeServer* s = Utils->FindServerMask(parameters[0]);
if (s)
{
if (s == Utils->TreeRoot)
{
user->WriteNotice("*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (" + parameters[0] + " matches local server name)");
return MOD_RES_DENY;
}
TreeSocket* sock = s->GetSocket();
if (sock)
{
ServerInstance->SNO->WriteToSnoMask('l',"SQUIT: Server \002%s\002 removed from network by %s",parameters[0].c_str(),user->nick.c_str());
sock->Squit(s,"Server quit by " + user->GetFullRealHost());
ServerInstance->SE->DelFd(sock);
sock->Close();
}
else
{
user->WriteNotice("*** SQUIT may not be used to remove remote servers. Please use RSQUIT instead.");
}
}
else
{
user->WriteNotice("*** SQUIT: The server \002" + parameters[0] + "\002 does not exist on the network.");
}
return MOD_RES_DENY;
}
/* returns a list of DIRECT servernames for a specific channel */
void SpanningTreeUtilities::GetListOfServersForChannel(Channel* c, TreeSocketSet& list, char status, const CUList& exempt_list)
{
unsigned int minrank = 0;
if (status)
{
PrefixMode* mh = ServerInstance->Modes->FindPrefix(status);
if (mh)
minrank = mh->GetPrefixRank();
}
const UserMembList *ulist = c->GetUsers();
for (UserMembCIter i = ulist->begin(); i != ulist->end(); i++)
{
if (IS_LOCAL(i->first))
continue;
if (minrank && i->second->getRank() < minrank)
continue;
if (exempt_list.find(i->first) == exempt_list.end())
{
TreeServer* best = TreeServer::Get(i->first);
list.insert(best->GetSocket());
}
}
return;
}
void SpanningTreeUtilities::DoOneToOne(const CmdBuilder& params, Server* server)
{
TreeServer* ts = static_cast<TreeServer*>(server);
TreeSocket* sock = ts->GetSocket();
if (sock)
sock->WriteLine(params);
}
int ModuleSpanningTree::HandleSquit(const char** parameters, int pcnt, userrec* user)
{
TreeServer* s = Utils->FindServerMask(parameters[0]);
if (s)
{
if (s == Utils->TreeRoot)
{
user->WriteServ("NOTICE %s :*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (%s matches local server name)",user->nick,parameters[0]);
return 1;
}
TreeSocket* sock = s->GetSocket();
if (sock)
{
ServerInstance->SNO->WriteToSnoMask('l',"SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick);
sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost());
ServerInstance->SE->DelFd(sock);
sock->Close();
}
else
{
if (IS_LOCAL(user))
user->WriteServ("NOTICE %s :*** WARNING: Using SQUIT to split remote servers is deprecated. Please use RSQUIT instead.",user->nick);
}
}
else
{
user->WriteServ("NOTICE %s :*** SQUIT: The server \002%s\002 does not exist on the network.",user->nick,parameters[0]);
}
return 1;
}
bool SpanningTreeUtilities::DoOneToMany(const std::string &prefix, const std::string &command, const parameterlist ¶ms)
{
std::string FullLine = ConstructLine(prefix, command, params);
unsigned int items = this->TreeRoot->ChildCount();
for (unsigned int x = 0; x < items; x++)
{
TreeServer* Route = this->TreeRoot->GetChild(x);
if (Route && Route->GetSocket())
{
TreeSocket* Sock = Route->GetSocket();
if (Sock)
Sock->WriteLine(FullLine);
}
}
return true;
}
bool SpanningTreeUtilities::DoOneToOne(const std::string& prefix, const std::string& command, const parameterlist& params, const std::string& target)
{
TreeServer* Route = this->BestRouteTo(target);
if (!Route)
return false;
Route->GetSocket()->WriteLine(ConstructLine(prefix, command, params));
return true;
}
bool SpanningTreeUtilities::DoOneToOne(const CmdBuilder& params, const std::string& target)
{
TreeServer* Route = this->BestRouteTo(target);
if (!Route)
return false;
Route->GetSocket()->WriteLine(params);
return true;
}
bool SpanningTreeUtilities::DoOneToOne(const std::string& prefix, const std::string& command, const parameterlist& params, const std::string& target)
{
TreeServer* Route = this->BestRouteTo(target);
if (Route)
{
if (Route && Route->GetSocket())
{
TreeSocket* Sock = Route->GetSocket();
if (Sock)
Sock->WriteLine(ConstructLine(prefix, command, params));
}
return true;
}
else
{
return false;
}
}
bool SpanningTreeUtilities::DoOneToAllButSender(const std::string& prefix, const std::string& command, const parameterlist& params, const std::string& omit)
{
TreeServer* omitroute = this->BestRouteTo(omit);
std::string FullLine = ConstructLine(prefix, command, params);
unsigned int items = this->TreeRoot->ChildCount();
for (unsigned int x = 0; x < items; x++)
{
TreeServer* Route = this->TreeRoot->GetChild(x);
// Send the line IF:
// The route has a socket (its a direct connection)
// The route isnt the one to be omitted
// The route isnt the path to the one to be omitted
if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route))
{
TreeSocket* Sock = Route->GetSocket();
if (Sock)
Sock->WriteLine(FullLine);
}
}
return true;
}
void SpanningTreeUtilities::DoOneToAllButSender(const CmdBuilder& params, TreeServer* omitroute)
{
const std::string& FullLine = params.str();
const TreeServer::ChildServers& children = TreeRoot->GetChildren();
for (TreeServer::ChildServers::const_iterator i = children.begin(); i != children.end(); ++i)
{
TreeServer* Route = *i;
// Send the line if the route isn't the path to the one to be omitted
if (Route != omitroute)
{
Route->GetSocket()->WriteLine(FullLine);
}
}
}
void SpanningTreeUtilities::DoOneToAllButSender(const std::string& prefix, const std::string& command, const parameterlist& params, TreeServer* omitroute)
{
std::string FullLine = ConstructLine(prefix, command, params);
const TreeServer::ChildServers& children = TreeRoot->GetChildren();
for (TreeServer::ChildServers::const_iterator i = children.begin(); i != children.end(); ++i)
{
TreeServer* Route = *i;
// Send the line if the route isn't the path to the one to be omitted
if (Route != omitroute)
{
Route->GetSocket()->WriteLine(FullLine);
}
}
}
void ModuleSpanningTree::DoPingChecks(time_t curtime)
{
for (unsigned int j = 0; j < Utils->TreeRoot->ChildCount(); j++)
{
TreeServer* serv = Utils->TreeRoot->GetChild(j);
TreeSocket* sock = serv->GetSocket();
if (sock)
{
if (curtime >= serv->NextPingTime())
{
if (serv->AnsweredLastPing())
{
sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName());
serv->SetNextPingTime(curtime + 60);
serv->LastPing = curtime;
serv->Warned = false;
}
else
{
/* they didnt answer, boot them */
sock->SendError("Ping timeout");
sock->Squit(serv,"Ping timeout");
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::DoPingChecks(time_t curtime)
{
/*
* Cancel remote burst mode on any servers which still have it enabled due to latency/lack of data.
* This prevents lost REMOTECONNECT notices
*/
timeval t;
gettimeofday(&t, NULL);
long ts = (t.tv_sec * 1000) + (t.tv_usec / 1000);
for (server_hash::iterator i = Utils->serverlist.begin(); i != Utils->serverlist.end(); i++)
{
TreeServer *s = i->second;
// Fix for bug #792, do not ping servers that are not connected yet!
// Remote servers have Socket == NULL and local connected servers have
// Socket->LinkState == CONNECTED
if (s->GetSocket() && s->GetSocket()->GetLinkState() != CONNECTED)
continue;
// Now do PING checks on all servers
TreeServer *mts = Utils->BestRouteTo(s->GetID());
if (mts)
{
// Only ping if this server needs one
if (curtime >= s->NextPingTime())
{
// And if they answered the last
if (s->AnsweredLastPing())
{
// They did, send a ping to them
s->SetNextPingTime(curtime + Utils->PingFreq);
TreeSocket *tsock = mts->GetSocket();
// ... if we can find a proper route to them
if (tsock)
{
tsock->WriteLine(std::string(":") + ServerInstance->Config->GetSID() + " PING " +
ServerInstance->Config->GetSID() + " " + s->GetID());
s->LastPingMsec = ts;
}
}
else
{
// They didn't answer the last ping, if they are locally connected, get rid of them.
TreeSocket *sock = s->GetSocket();
if (sock)
{
sock->SendError("Ping timeout");
sock->Squit(s,"Ping timeout");
ServerInstance->SE->DelFd(sock);
sock->Close();
return;
}
}
}
// If warn on ping enabled and not warned and the difference is sufficient and they didn't answer the last ping...
if ((Utils->PingWarnTime) && (!s->Warned) && (curtime >= s->NextPingTime() - (Utils->PingFreq - Utils->PingWarnTime)) && (!s->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.", s->GetName().c_str(), Utils->PingWarnTime);
s->Warned = true;
}
}
}
}
