X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmodules%2Fm_spanningtree%2Ftreeserver.cpp;h=ca7959ea7d44dacb8787e9641a00a5ece1ae0767;hb=c6e40d36b42a7ebf832c3a57d2816a47ee9c9a76;hp=7d8abf4bf4b9a855dff1d1e44b02ba4e54c8e30c;hpb=8acee01804e96f80bb980137738764573780a642;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_spanningtree/treeserver.cpp b/src/modules/m_spanningtree/treeserver.cpp
index 7d8abf4bf..ca7959ea7 100644
--- a/src/modules/m_spanningtree/treeserver.cpp
+++ b/src/modules/m_spanningtree/treeserver.cpp
@@ -23,7 +23,7 @@
 #include "inspircd.h"
 #include "xline.h"
 #include "main.h"
-#include "modules/spanningtree.h"
+#include "modules/server.h"
 
 #include "utils.h"
 #include "treeserver.h"
@@ -33,27 +33,35 @@
  * no socket associated with it. Its version string is our own local version.
  */
 TreeServer::TreeServer()
-	: Parent(NULL), Route(NULL), ServerName(ServerInstance->Config->ServerName), ServerDesc(ServerInstance->Config->ServerDesc)
-	, VersionString(ServerInstance->GetVersionString()), Socket(NULL), sid(ServerInstance->Config->GetSID()), ServerUser(ServerInstance->FakeClient)
-	, age(ServerInstance->Time()), Warned(false), bursting(false), UserCount(0), OperCount(0), rtt(0), StartBurst(0), Hidden(false)
+	: Server(ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc)
+	, Parent(NULL), Route(NULL)
+	, VersionString(ServerInstance->GetVersionString())
+	, fullversion(ServerInstance->GetVersionString(true))
+	, rawversion(INSPIRCD_VERSION)
+	, Socket(NULL), sid(ServerInstance->Config->GetSID()), behind_bursting(0), isdead(false)
+	, pingtimer(this)
+	, ServerUser(ServerInstance->FakeClient)
+	, age(ServerInstance->Time()), UserCount(ServerInstance->Users.LocalUserCount())
+	, OperCount(0), rtt(0), StartBurst(0), Hidden(false)
 {
 	AddHashEntry();
 }
 
 /** When we create a new server, we call this constructor to initialize it.
  * This constructor initializes the server's Route and Parent, and sets up
- * its ping counters so that it will be pinged one minute from now.
+ * the ping timer for the server.
  */
 TreeServer::TreeServer(const std::string& Name, const std::string& Desc, const std::string& id, TreeServer* Above, TreeSocket* Sock, bool Hide)
-	: Parent(Above), ServerName(Name), ServerDesc(Desc), Socket(Sock), sid(id), ServerUser(new FakeUser(id, Name))
-	, age(ServerInstance->Time()), Warned(false), bursting(true), UserCount(0), OperCount(0), rtt(0), Hidden(Hide)
+	: Server(Name, Desc)
+	, Parent(Above), Socket(Sock), sid(id), behind_bursting(Parent->behind_bursting), isdead(false)
+	, pingtimer(this)
+	, ServerUser(new FakeUser(id, this))
+	, age(ServerInstance->Time()), UserCount(0), OperCount(0), rtt(0), StartBurst(0), Hidden(Hide)
 {
-	SetNextPingTime(ServerInstance->Time() + Utils->PingFreq);
-	SetPingFlag();
+	ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "New server %s behind_bursting %u", GetName().c_str(), behind_bursting);
+	CheckULine();
 
-	long ts = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000);
-	this->StartBurst = ts;
-	ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Server %s started bursting at time %lu", sid.c_str(), ts);
+	ServerInstance->Timers.AddTimer(&pingtimer);
 
 	/* find the 'route' for this server (e.g. the one directly connected
 	 * to the local server, which we can use to reach it)
@@ -107,18 +115,31 @@ TreeServer::TreeServer(const std::string& Name, const std::string& Desc, const s
 	 */
 
 	this->AddHashEntry();
+	Parent->Children.push_back(this);
+
+	FOREACH_MOD_CUSTOM(Utils->Creator->GetEventProvider(), ServerEventListener, OnServerLink, (this));
 }
 
-const std::string& TreeServer::GetID()
+void TreeServer::BeginBurst(uint64_t startms)
 {
-	return sid;
+	behind_bursting++;
+
+	uint64_t now = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000);
+	// If the start time is in the future (clocks are not synced) then use current time
+	if ((!startms) || (startms > now))
+		startms = now;
+	this->StartBurst = startms;
+	ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Server %s started bursting at time %s behind_bursting %u", sid.c_str(), ConvToStr(startms).c_str(), behind_bursting);
 }
 
 void TreeServer::FinishBurstInternal()
 {
-	this->bursting = false;
-	SetNextPingTime(ServerInstance->Time() + Utils->PingFreq);
-	SetPingFlag();
+	// Check is needed because 1202 protocol servers don't send the bursting state of a server, so servers
+	// introduced during a netburst may later send ENDBURST which would normally decrease this counter
+	if (behind_bursting > 0)
+		behind_bursting--;
+	ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "FinishBurstInternal() %s behind_bursting %u", GetName().c_str(), behind_bursting);
+
 	for (ChildServers::const_iterator i = Children.begin(); i != Children.end(); ++i)
 	{
 		TreeServer* child = *i;
@@ -128,133 +149,128 @@ void TreeServer::FinishBurstInternal()
 
 void TreeServer::FinishBurst()
 {
-	FinishBurstInternal();
 	ServerInstance->XLines->ApplyLines();
-	long ts = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000);
+	uint64_t ts = ServerInstance->Time() * 1000 + (ServerInstance->Time_ns() / 1000000);
 	unsigned long bursttime = ts - this->StartBurst;
 	ServerInstance->SNO->WriteToSnoMask(Parent == Utils->TreeRoot ? 'l' : 'L', "Received end of netburst from \2%s\2 (burst time: %lu %s)",
-		ServerName.c_str(), (bursttime > 10000 ? bursttime / 1000 : bursttime), (bursttime > 10000 ? "secs" : "msecs"));
-	AddServerEvent(Utils->Creator, ServerName);
+		GetName().c_str(), (bursttime > 10000 ? bursttime / 1000 : bursttime), (bursttime > 10000 ? "secs" : "msecs"));
+
+	StartBurst = 0;
+	FinishBurstInternal();
 }
 
-int TreeServer::QuitUsers(const std::string &reason)
+void TreeServer::SQuitChild(TreeServer* server, const std::string& reason)
 {
-	std::string publicreason = ServerInstance->Config->HideSplits ? "*.net *.split" : reason;
+	stdalgo::erase(Children, server);
 
-	const user_hash& users = *ServerInstance->Users->clientlist;
-	unsigned int original_size = users.size();
-	for (user_hash::const_iterator i = users.begin(); i != users.end(); )
+	if (IsRoot())
 	{
-		User* user = i->second;
-		// Increment the iterator now because QuitUser() removes the user from the container
-		++i;
-		if (user->server == ServerName)
-			ServerInstance->Users->QuitUser(user, publicreason, &reason);
+		// Server split from us, generate a SQUIT message and broadcast it
+		ServerInstance->SNO->WriteGlobalSno('l', "Server \002" + server->GetName() + "\002 split: " + reason);
+		CmdBuilder("SQUIT").push(server->GetID()).push_last(reason).Broadcast();
+	}
+	else
+	{
+		ServerInstance->SNO->WriteToSnoMask('L', "Server \002" + server->GetName() + "\002 split from server \002" + GetName() + "\002 with reason: " + reason);
 	}
-	return original_size - users.size();
-}
 
-/** This method is used to add the structure to the
- * hash_map for linear searches. It is only called
- * by the constructors.
- */
-void TreeServer::AddHashEntry()
-{
-	Utils->serverlist[ServerName] = this;
-	Utils->sidlist[sid] = this;
-}
+	unsigned int num_lost_servers = 0;
+	server->SQuitInternal(num_lost_servers);
 
-/** These accessors etc should be pretty self-
- * explanitory.
- */
-TreeServer* TreeServer::GetRoute()
-{
-	return Route;
-}
+	const std::string quitreason = GetName() + " " + server->GetName();
+	unsigned int num_lost_users = QuitUsers(quitreason);
 
-const std::string& TreeServer::GetDesc()
-{
-	return ServerDesc;
-}
+	ServerInstance->SNO->WriteToSnoMask(IsRoot() ? 'l' : 'L', "Netsplit complete, lost \002%u\002 user%s on \002%u\002 server%s.",
+		num_lost_users, num_lost_users != 1 ? "s" : "", num_lost_servers, num_lost_servers != 1 ? "s" : "");
 
-const std::string& TreeServer::GetVersion()
-{
-	return VersionString;
-}
+	// No-op if the socket is already closed (i.e. it called us)
+	if (server->IsLocal())
+		server->GetSocket()->Close();
 
-void TreeServer::SetNextPingTime(time_t t)
-{
-	this->NextPing = t;
-	LastPingWasGood = false;
+	// Add the server to the cull list, the servers behind it are handled by cull() and the destructor
+	ServerInstance->GlobalCulls.AddItem(server);
 }
 
-time_t TreeServer::NextPingTime()
+void TreeServer::SQuitInternal(unsigned int& num_lost_servers)
 {
-	return NextPing;
-}
+	ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Server %s lost in split", GetName().c_str());
 
-bool TreeServer::AnsweredLastPing()
-{
-	return LastPingWasGood;
-}
+	for (ChildServers::const_iterator i = Children.begin(); i != Children.end(); ++i)
+	{
+		TreeServer* server = *i;
+		server->SQuitInternal(num_lost_servers);
+	}
 
-void TreeServer::SetPingFlag()
-{
-	LastPingWasGood = true;
-}
+	// Mark server as dead
+	isdead = true;
+	num_lost_servers++;
+	RemoveHash();
 
-TreeSocket* TreeServer::GetSocket()
-{
-	return Socket;
+	if (!Utils->Creator->dying)
+		FOREACH_MOD_CUSTOM(Utils->Creator->GetEventProvider(), ServerEventListener, OnServerSplit, (this));
 }
 
-TreeServer* TreeServer::GetParent()
+unsigned int TreeServer::QuitUsers(const std::string& reason)
 {
-	return Parent;
-}
+	std::string publicreason = ServerInstance->Config->HideSplits ? "*.net *.split" : reason;
 
-void TreeServer::SetVersion(const std::string &Version)
-{
-	VersionString = Version;
+	const user_hash& users = ServerInstance->Users->GetUsers();
+	unsigned int original_size = users.size();
+	for (user_hash::const_iterator i = users.begin(); i != users.end(); )
+	{
+		User* user = i->second;
+		// Increment the iterator now because QuitUser() removes the user from the container
+		++i;
+		TreeServer* server = TreeServer::Get(user);
+		if (server->IsDead())
+			ServerInstance->Users->QuitUser(user, publicreason, &reason);
+	}
+	return original_size - users.size();
 }
 
-void TreeServer::AddChild(TreeServer* Child)
+void TreeServer::CheckULine()
 {
-	Children.push_back(Child);
-}
+	uline = silentuline = false;
 
-bool TreeServer::DelChild(TreeServer* Child)
-{
-	std::vector<TreeServer*>::iterator it = std::find(Children.begin(), Children.end(), Child);
-	if (it != Children.end())
+	ConfigTagList tags = ServerInstance->Config->ConfTags("uline");
+	for (ConfigIter i = tags.first; i != tags.second; ++i)
 	{
-		Children.erase(it);
-		return true;
+		ConfigTag* tag = i->second;
+		std::string server = tag->getString("server");
+		if (!strcasecmp(server.c_str(), GetName().c_str()))
+		{
+			if (this->IsRoot())
+			{
+				ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Servers should not uline themselves (at " + tag->getTagLocation() + ")");
+				return;
+			}
+
+			uline = true;
+			silentuline = tag->getBool("silent");
+			break;
+		}
 	}
-	return false;
 }
 
-/** Removes child nodes of this node, and of that node, etc etc.
- * This is used during netsplits to automatically tidy up the
- * server tree. It is slow, we don't use it for much else.
+/** This method is used to add the server to the
+ * maps for linear searches. It is only called
+ * by the constructors.
  */
-void TreeServer::Tidy()
+void TreeServer::AddHashEntry()
 {
-	while (1)
-	{
-		std::vector<TreeServer*>::iterator a = Children.begin();
-		if (a == Children.end())
-			return;
-		TreeServer* s = *a;
-		s->Tidy();
-		s->cull();
-		Children.erase(a);
-		delete s;
-	}
+	Utils->serverlist[GetName()] = this;
+	Utils->sidlist[sid] = this;
 }
 
 CullResult TreeServer::cull()
 {
+	// Recursively cull all servers that are under us in the tree
+	for (ChildServers::const_iterator i = Children.begin(); i != Children.end(); ++i)
+	{
+		TreeServer* server = *i;
+		server->cull();
+	}
+
 	if (!IsRoot())
 		ServerUser->cull();
 	return classbase::cull();
@@ -262,10 +278,17 @@ CullResult TreeServer::cull()
 
 TreeServer::~TreeServer()
 {
-	/* We'd better tidy up after ourselves, eh? */
+	// Recursively delete all servers that are under us in the tree first
+	for (ChildServers::const_iterator i = Children.begin(); i != Children.end(); ++i)
+		delete *i;
+
+	// Delete server user unless it's us
 	if (!IsRoot())
 		delete ServerUser;
+}
 
+void TreeServer::RemoveHash()
+{
 	Utils->sidlist.erase(sid);
-	Utils->serverlist.erase(ServerName);
+	Utils->serverlist.erase(GetName());
 }