1 /* +------------------------------------+
\r * | Inspire Internet Relay Chat Daemon |
\r * +------------------------------------+
\r *
\r * InspIRCd: (C) 2002-2007 InspIRCd Development Team
\r * See: http://www.inspircd.org/wiki/index.php/Credits
\r *
\r * This program is free but copyrighted software; see
\r * the file COPYING for details.
\r *
\r * ---------------------------------------------------
\r */
\r\r#include "inspircd.h"
\r#include "configreader.h"
\r#include "users.h"
\r#include "channels.h"
\r#include "modules.h"
\r#include "commands/cmd_whois.h"
\r#include "commands/cmd_stats.h"
\r#include "socket.h"
\r#include "wildcard.h"
\r#include "xline.h"
\r#include "transport.h"
\r\r#include "m_spanningtree/utils.h"
\r#include "m_spanningtree/treeserver.h"
\r\r/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h */
\r\rTreeServer::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance) : ServerInstance(Instance), Utils(Util)
\r{
\r Parent = NULL;
\r ServerName.clear();
\r ServerDesc.clear();
\r VersionString.clear();
\r UserCount = OperCount = 0;
\r rtt = LastPing = 0;
\r Hidden = false;
\r VersionString = ServerInstance->GetVersionString();
\r}
\r\r/** We use this constructor only to create the 'root' item, Utils->TreeRoot, which
\r * represents our own server. Therefore, it has no route, no parent, and
\r * no socket associated with it. Its version string is our own local version.
\r */
\rTreeServer::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc) : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc), Utils(Util)
\r{
\r Parent = NULL;
\r VersionString.clear();
\r UserCount = ServerInstance->UserCount();
\r OperCount = ServerInstance->OperCount();
\r VersionString = ServerInstance->GetVersionString();
\r Route = NULL;
\r Socket = NULL; /* Fix by brain */
\r rtt = LastPing = 0;
\r Hidden = false;
\r AddHashEntry();
\r}
\r\r/** When we create a new server, we call this constructor to initialize it.
\r * This constructor initializes the server's Route and Parent, and sets up
\r * its ping counters so that it will be pinged one minute from now.
\r */
\rTreeServer::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock, bool Hide)
\r : ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock), Utils(Util), Hidden(Hide)
\r{
\r VersionString.clear();
\r UserCount = OperCount = 0;
\r this->SetNextPingTime(time(NULL) + 60);
\r this->SetPingFlag();
\r rtt = LastPing = 0;
\r /* find the 'route' for this server (e.g. the one directly connected
\r * to the local server, which we can use to reach it)
\r *
\r * In the following example, consider we have just added a TreeServer
\r * class for server G on our network, of which we are server A.
\r * To route traffic to G (marked with a *) we must send the data to
\r * B (marked with a +) so this algorithm initializes the 'Route'
\r * value to point at whichever server traffic must be routed through
\r * to get here. If we were to try this algorithm with server B,
\r * the Route pointer would point at its own object ('this').
\r *
\r * A
\r * / \
\r * + B C
\r * / \ \
\r * D E F
\r * / \
\r * * G H
\r *
\r * We only run this algorithm when a server is created, as
\r * the routes remain constant while ever the server exists, and
\r * do not need to be re-calculated.
\r */
\r\r Route = Above;
\r if (Route == Utils->TreeRoot)
\r {
\r Route = this;
\r }
\r else
\r {
\r while (this->Route->GetParent() != Utils->TreeRoot)
\r {
\r this->Route = Route->GetParent();
\r }
\r }
\r\r /* Because recursive code is slow and takes a lot of resources,
\r * we store two representations of the server tree. The first
\r * is a recursive structure where each server references its
\r * children and its parent, which is used for netbursts and
\r * netsplits to dump the whole dataset to the other server,
\r * and the second is used for very fast lookups when routing
\r * messages and is instead a hash_map, where each item can
\r * be referenced by its server name. The AddHashEntry()
\r * call below automatically inserts each TreeServer class
\r * into the hash_map as it is created. There is a similar
\r * maintainance call in the destructor to tidy up deleted
\r * servers.
\r */
\r\r this->AddHashEntry();
\r}
\r\rint TreeServer::QuitUsers(const std::string &reason)
\r{
\r const char* reason_s = reason.c_str();
\r std::vector<userrec*> time_to_die;
\r for (user_hash::iterator n = ServerInstance->clientlist->begin(); n != ServerInstance->clientlist->end(); n++)
\r {
\r if (!strcmp(n->second->server, this->ServerName.c_str()))
\r {
\r time_to_die.push_back(n->second);
\r }
\r }
\r for (std::vector<userrec*>::iterator n = time_to_die.begin(); n != time_to_die.end(); n++)
\r {
\r userrec* a = (userrec*)*n;
\r if (!IS_LOCAL(a))
\r {
\r if (ServerInstance->Config->HideSplits)
\r userrec::QuitUser(ServerInstance, a, "*.net *.split", reason_s);
\r else
\r userrec::QuitUser(ServerInstance, a, reason_s);
\r\r if (this->Utils->quiet_bursts)
\r ServerInstance->GlobalCulls.MakeSilent(a);
\r }
\r }
\r return time_to_die.size();
\r}
\r\r/** This method is used to add the structure to the
\r * hash_map for linear searches. It is only called
\r * by the constructors.
\r */
\rvoid TreeServer::AddHashEntry()
\r{
\r server_hash::iterator iter = Utils->serverlist.find(this->ServerName.c_str());
\r if (iter == Utils->serverlist.end())
\r Utils->serverlist[this->ServerName.c_str()] = this;
\r}
\r\r/** This method removes the reference to this object
\r * from the hash_map which is used for linear searches.
\r * It is only called by the default destructor.
\r */
\rvoid TreeServer::DelHashEntry()
\r{
\r server_hash::iterator iter = Utils->serverlist.find(this->ServerName.c_str());
\r if (iter != Utils->serverlist.end())
\r Utils->serverlist.erase(iter);
\r}
\r\r/** These accessors etc should be pretty self-
\r * explanitory.
\r */
\rTreeServer* TreeServer::GetRoute()
\r{
\r return Route;
\r}
\r\rstd::string TreeServer::GetName()
\r{
\r return ServerName.c_str();
\r}
\r\rstd::string TreeServer::GetDesc()
\r{
\r return ServerDesc;
\r}
\r\rstd::string TreeServer::GetVersion()
\r{
\r return VersionString;
\r}
\r\rvoid TreeServer::SetNextPingTime(time_t t)
\r{
\r this->NextPing = t;
\r LastPingWasGood = false;
\r}
\r\rtime_t TreeServer::NextPingTime()
\r{
\r return NextPing;
\r}
\r\rbool TreeServer::AnsweredLastPing()
\r{
\r return LastPingWasGood;
\r}
\r\rvoid TreeServer::SetPingFlag()
\r{
\r LastPingWasGood = true;
\r}
\r\rint TreeServer::GetUserCount()
\r{
\r return UserCount;
\r}
\r\rvoid TreeServer::AddUserCount()
\r{
\r UserCount++;
\r}
\r\rvoid TreeServer::DelUserCount()
\r{
\r UserCount--;
\r}
\r\rint TreeServer::GetOperCount()
\r{
\r return OperCount;
\r}
\r\rTreeSocket* TreeServer::GetSocket()
\r{
\r return Socket;
\r}
\r\rTreeServer* TreeServer::GetParent()
\r{
\r return Parent;
\r}
\r\rvoid TreeServer::SetVersion(const std::string &Version)
\r{
\r VersionString = Version;
\r}
\r\runsigned int TreeServer::ChildCount()
\r{
\r return Children.size();
\r}
\r\rTreeServer* TreeServer::GetChild(unsigned int n)
\r{
\r if (n < Children.size())
\r {
\r /* Make sure they cant request
\r * an out-of-range object. After
\r * all we know what these programmer
\r * types are like *grin*.
\r */
\r return Children[n];
\r }
\r else
\r {
\r return NULL;
\r }
\r}
\r\rvoid TreeServer::AddChild(TreeServer* Child)
\r{
\r Children.push_back(Child);
\r}
\r\rbool TreeServer::DelChild(TreeServer* Child)
\r{
\r for (std::vector<TreeServer*>::iterator a = Children.begin(); a < Children.end(); a++)
\r {
\r if (*a == Child)
\r {
\r Children.erase(a);
\r return true;
\r }
\r }
\r return false;
\r}
\r\r/** Removes child nodes of this node, and of that node, etc etc.
\r * This is used during netsplits to automatically tidy up the
\r * server tree. It is slow, we don't use it for much else.
\r */
\rbool TreeServer::Tidy()
\r{
\r bool stillchildren = true;
\r while (stillchildren)
\r {
\r stillchildren = false;
\r for (std::vector<TreeServer*>::iterator a = Children.begin(); a < Children.end(); a++)
\r {
\r TreeServer* s = (TreeServer*)*a;
\r s->Tidy();
\r Children.erase(a);
\r DELETE(s);
\r stillchildren = true;
\r break;
\r }
\r }
\r return true;
\r}
\r\rTreeServer::~TreeServer()
\r{
\r /* We'd better tidy up after ourselves, eh? */
\r this->DelHashEntry();
\r}
\r\r\r