X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Fnetburst.cpp;h=a33cf8a134004f22a690ea5344f7d07dfc43acfb;hb=c8f92d97c2cd92a07bbb76b96a67cd089c7e3407;hp=938585c847d588bed3c00c2fd3422dc8a94509e7;hpb=7264a6a8d4360989ca2f64230da07c562d0f34f1;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_spanningtree/netburst.cpp b/src/modules/m_spanningtree/netburst.cpp
index 938585c84..a33cf8a13 100644
--- a/src/modules/m_spanningtree/netburst.cpp
+++ b/src/modules/m_spanningtree/netburst.cpp
@@ -26,6 +26,75 @@
 #include "treesocket.h"
 #include "treeserver.h"
 #include "main.h"
+#include "commands.h"
+#include "protocolinterface.h"
+
+/**
+ * Creates FMODE messages, used only when syncing channels
+ */
+class FModeBuilder : public CmdBuilder
+{
+	static const size_t maxline = 480;
+	std::string params;
+	unsigned int modes;
+	std::string::size_type startpos;
+
+ public:
+	FModeBuilder(Channel* chan)
+		: CmdBuilder("FMODE"), modes(0)
+	{
+		push(chan->name).push_int(chan->age).push_raw(" +");
+		startpos = str().size();
+	}
+
+	/** Add a mode to the message
+	 */
+	void push_mode(const char modeletter, const std::string& mask)
+	{
+		push_raw(modeletter);
+		params.push_back(' ');
+		params.append(mask);
+		modes++;
+	}
+
+	/** Remove all modes from the message
+	 */
+	void clear()
+	{
+		content.erase(startpos);
+		params.clear();
+		modes = 0;
+	}
+
+	/** Prepare the message for sending, next mode can only be added after clear()
+	 */
+	const std::string& finalize()
+	{
+		return push_raw(params);
+	}
+
+	/** Returns true if the given mask can be added to the message, false if the message
+	 * has no room for the mask
+	 */
+	bool has_room(const std::string& mask) const
+	{
+		return ((str().size() + params.size() + mask.size() + 2 <= maxline) &&
+				(modes < ServerInstance->Config->Limits.MaxModes));
+	}
+
+	/** Returns true if this message is empty (has no modes)
+	 */
+	bool empty() const
+	{
+		return (modes == 0);
+	}
+};
+
+struct TreeSocket::BurstState
+{
+	SpanningTreeProtocolInterface::Server server;
+	BurstState(TreeSocket* sock) : server(sock) { }
+};
 
 /** This function is called when we want to send a netburst to a local
  * server. There is a set order we must do this, because for example
@@ -44,14 +113,17 @@ void TreeSocket::DoBurst(TreeServer* s)
 	this->WriteLine(":" + ServerInstance->Config->GetSID() + " VERSION :"+ServerInstance->GetVersionString());
 	/* Send server tree */
 	this->SendServers(Utils->TreeRoot, s);
+
+	BurstState bs(this);
 	/* Send users and their oper status */
-	this->SendUsers();
+	this->SendUsers(bs);
 
-	for (chan_hash::const_iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); ++i)
-		SyncChannel(i->second);
+	const chan_hash& chans = ServerInstance->GetChans();
+	for (chan_hash::const_iterator i = chans.begin(); i != chans.end(); ++i)
+		SyncChannel(i->second, bs);
 
 	this->SendXLines();
-	FOREACH_MOD(OnSyncNetwork, (Utils->Creator,(void*)this));
+	FOREACH_MOD(OnSyncNetwork, (bs.server));
 	this->WriteLine(":" + ServerInstance->Config->GetSID() + " ENDBURST");
 	ServerInstance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+ s->GetName()+"\2.");
 }
@@ -71,8 +143,7 @@ void TreeSocket::SendServers(TreeServer* Current, TreeServer* s)
 		TreeServer* recursive_server = *i;
 		if (recursive_server != s)
 		{
-			this->WriteLine(InspIRCd::Format(":%s SERVER %s * 0 %s :%s", Current->GetID().c_str(),
-				recursive_server->GetName().c_str(), recursive_server->GetID().c_str(), recursive_server->GetDesc().c_str()));
+			this->WriteLine(CommandServer::Builder(recursive_server));
 			this->WriteLine(":" + recursive_server->GetID() + " VERSION :" + recursive_server->GetVersion());
 			/* down to next level */
 			this->SendServers(recursive_server, s);
@@ -107,9 +178,6 @@ void TreeSocket::SendFJoins(Channel* c)
 		line.append(modestr).append(1, ',').append(i->first->uuid).push_back(' ');
 	}
 	this->WriteLine(line);
-
-	ChanModeReference ban(NULL, "ban");
-	static_cast<ListModeBase*>(*ban)->DoSyncChannel(c, Utils->Creator, this);
 }
 
 /** Send all XLines we know about */
@@ -133,88 +201,101 @@ void TreeSocket::SendXLines()
 				if (!i->second->IsBurstable())
 					break;
 
-				this->WriteLine(InspIRCd::Format(":%s ADDLINE %s %s %s %lu %lu :%s",
-					ServerInstance->Config->GetSID().c_str(),
-					it->c_str(),
-					i->second->Displayable().c_str(),
-					i->second->source.c_str(),
-					(unsigned long)i->second->set_time,
-					(unsigned long)i->second->duration,
-					i->second->reason.c_str()));
+				this->WriteLine(CommandAddLine::Builder(i->second));
 			}
 		}
 	}
 }
 
+void TreeSocket::SendListModes(Channel* chan)
+{
+	FModeBuilder fmode(chan);
+	const ModeParser::ListModeList& listmodes = ServerInstance->Modes->GetListModes();
+	for (ModeParser::ListModeList::const_iterator i = listmodes.begin(); i != listmodes.end(); ++i)
+	{
+		ListModeBase* mh = *i;
+		ListModeBase::ModeList* list = mh->GetList(chan);
+		if (!list)
+			continue;
+
+		// Add all items on the list to the FMODE, send it whenever it becomes too long
+		const char modeletter = mh->GetModeChar();
+		for (ListModeBase::ModeList::const_iterator j = list->begin(); j != list->end(); ++j)
+		{
+			const std::string& mask = j->mask;
+			if (!fmode.has_room(mask))
+			{
+				// No room for this mask, send the current line as-is then add the mask to a
+				// new, empty FMODE message
+				this->WriteLine(fmode.finalize());
+				fmode.clear();
+			}
+			fmode.push_mode(modeletter, mask);
+		}
+	}
+
+	if (!fmode.empty())
+		this->WriteLine(fmode.finalize());
+}
+
 /** Send channel topic, modes and metadata */
-void TreeSocket::SyncChannel(Channel* chan)
+void TreeSocket::SyncChannel(Channel* chan, BurstState& bs)
 {
 	SendFJoins(chan);
 
 	// If the topic was ever set, send it, even if it's empty now
 	// because a new empty topic should override an old non-empty topic
 	if (chan->topicset != 0)
-	{
-		this->WriteLine(InspIRCd::Format(":%s FTOPIC %s %lu %lu %s :%s", ServerInstance->Config->GetSID().c_str(),
-			chan->name.c_str(), (unsigned long)chan->age, (unsigned long)chan->topicset,
-			chan->setby.c_str(), chan->topic.c_str()));
-	}
+		this->WriteLine(CommandFTopic::Builder(chan));
+
+	SendListModes(chan);
 
 	for (Extensible::ExtensibleStore::const_iterator i = chan->GetExtList().begin(); i != chan->GetExtList().end(); i++)
 	{
 		ExtensionItem* item = i->first;
 		std::string value = item->serialize(FORMAT_NETWORK, chan, i->second);
 		if (!value.empty())
-			Utils->Creator->ProtoSendMetaData(this, chan, item->name, value);
+			this->WriteLine(CommandMetadata::Builder(chan, item->name, value));
 	}
 
-	FOREACH_MOD(OnSyncChannel, (chan, Utils->Creator, this));
+	FOREACH_MOD(OnSyncChannel, (chan, bs.server));
+}
+
+void TreeSocket::SyncChannel(Channel* chan)
+{
+	BurstState bs(this);
+	SyncChannel(chan, bs);
 }
 
 /** send all users and their oper state/modes */
-void TreeSocket::SendUsers()
+void TreeSocket::SendUsers(BurstState& bs)
 {
-	for (user_hash::iterator u = ServerInstance->Users->clientlist->begin(); u != ServerInstance->Users->clientlist->end(); u++)
+	ProtocolInterface::Server& piserver = bs.server;
+
+	const user_hash& users = ServerInstance->Users->GetUsers();
+	for (user_hash::const_iterator u = users.begin(); u != users.end(); ++u)
 	{
-		if (u->second->registered == REG_ALL)
-		{
-			TreeServer* theirserver = Utils->FindServer(u->second->server);
-			if (theirserver)
-			{
-				this->WriteLine(InspIRCd::Format(":%s UID %s %lu %s %s %s %s %s %lu +%s :%s",
-					theirserver->GetID().c_str(),     // Prefix: SID
-					u->second->uuid.c_str(),          // 0: UUID
-					(unsigned long)u->second->age,    // 1: TS
-					u->second->nick.c_str(),          // 2: Nick
-					u->second->host.c_str(),          // 3: Real host
-					u->second->dhost.c_str(),         // 4: Display host
-					u->second->ident.c_str(),         // 5: Ident
-					u->second->GetIPString().c_str(), // 6: IP address
-					(unsigned long)u->second->signon, // 7: Signon time
-					u->second->FormatModes(true),     // 8...n: User modes and params
-					u->second->fullname.c_str()));    // size-1: GECOS
-
-				if (u->second->IsOper())
-				{
-					this->WriteLine(InspIRCd::Format(":%s OPERTYPE :%s", u->second->uuid.c_str(), u->second->oper->name.c_str()));
-				}
-				if (u->second->IsAway())
-				{
-					this->WriteLine(InspIRCd::Format(":%s AWAY %ld :%s", u->second->uuid.c_str(), (long)u->second->awaytime,
-						u->second->awaymsg.c_str()));
-				}
-			}
+		User* user = u->second;
+		if (user->registered != REG_ALL)
+			continue;
 
-			for(Extensible::ExtensibleStore::const_iterator i = u->second->GetExtList().begin(); i != u->second->GetExtList().end(); i++)
-			{
-				ExtensionItem* item = i->first;
-				std::string value = item->serialize(FORMAT_NETWORK, u->second, i->second);
-				if (!value.empty())
-					Utils->Creator->ProtoSendMetaData(this, u->second, item->name, value);
-			}
+		this->WriteLine(CommandUID::Builder(user));
+
+		if (user->IsOper())
+			this->WriteLine(CommandOpertype::Builder(user));
+
+		if (user->IsAway())
+			this->WriteLine(CommandAway::Builder(user));
 
-			FOREACH_MOD(OnSyncUser, (u->second,Utils->Creator,this));
+		const Extensible::ExtensibleStore& exts = user->GetExtList();
+		for (Extensible::ExtensibleStore::const_iterator i = exts.begin(); i != exts.end(); ++i)
+		{
+			ExtensionItem* item = i->first;
+			std::string value = item->serialize(FORMAT_NETWORK, u->second, i->second);
+			if (!value.empty())
+				this->WriteLine(CommandMetadata::Builder(user, item->name, value));
 		}
+
+		FOREACH_MOD(OnSyncUser, (user, piserver));
 	}
 }
-