Add basic stuff for protocol interface and implement a couple of the methods. It's all in ServerInstance->PI for calls from other modules/the core

git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@9297 e03df62e-2008-0410-955e-edbf42e46eb7

6 files changed, 146 insertions, 2 deletions

diff --git a/include/inspircd.h b/include/inspircd.h
index 05e33cf0c..c1c6379a4 100644
--- a/include/inspircd.h
+++ b/include/inspircd.h
@@ -56,6 +56,7 @@
 #include "modules.h"
 #include "configreader.h"
 #include "inspstring.h"
+#include "protocol.h"
 
 /**
  * Used to define the maximum number of parameters a command may have.
@@ -463,6 +464,10 @@ class CoreExport InspIRCd : public classbase
 	 */
 	int s_signal;
 
+	/** Protocol interface, overridden by server protocol modules
+	 */
+	ProtocolInterface* PI;
+
 	/** Get the current time
 	 * Because this only calls time() once every time around the mainloop,
 	 * it is much faster than calling time() directly.
diff --git a/include/protocol.h b/include/protocol.h
new file mode 100644
index 000000000..65369e781
--- /dev/null
+++ b/include/protocol.h
@@ -0,0 +1,40 @@
+/*       +------------------------------------+
+ *       | Inspire Internet Relay Chat Daemon |
+ *       +------------------------------------+
+ *
+ *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
+ *
+ * This program is free but copyrighted software; see
+ *            the file COPYING for details.
+ *
+ * ---------------------------------------------------
+ */
+
+#ifndef __PROTOCOL_H__
+#define __PROTOCOL_H__
+
+class InspIRCd;
+
+typedef std::deque<std::string> parameterlist;
+
+class ProtocolInterface : public Extensible
+{
+ protected:
+	InspIRCd* ServerInstance;
+ public:
+	ProtocolInterface(InspIRCd* Instance) : ServerInstance(Instance) { }
+	virtual ~ProtocolInterface() { }
+
+	virtual void SendEncapsulatedData(parameterlist &encap) { }
+	virtual void SendMetaData(void* target, int type, const std::string &key, const std::string &data) { }
+	virtual void SendTopic(Channel* channel, std::string &topic) { }
+	virtual void SendMode(const std::string &origin, const std::string &target, parameterlist &modedata) { }
+	virtual void SendOperNotice(const std::string &text) { }
+	virtual void SendModeNotice(const std::string &modes, const std::string &text) { }
+	virtual void SendSNONotice(const std::string &snomask, const std::string &text) { }
+	virtual void PushToClient(User* target, const std::string &rawline) { }
+};
+
+#endif
+
diff --git a/src/inspircd.cpp b/src/inspircd.cpp
index cd13087cf..5f50e900c 100644
--- a/src/inspircd.cpp
+++ b/src/inspircd.cpp
@@ -309,11 +309,13 @@ InspIRCd::InspIRCd(int argc, char** argv)
 	SE = SEF->Create(this);
 	delete SEF;
 
-
 	ThreadEngineFactory* tef = new ThreadEngineFactory();
 	this->Threads = tef->Create(this);
 	delete tef;
 
+	/* Default implementation does nothing */
+	this->PI = new ProtocolInterface(this);
+
 	this->s_signal = 0;
 	
 	// Create base manager classes early, so nothing breaks
diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp
index b1f5d3153..e5c7518e7 100644
--- a/src/modules/m_spanningtree/main.cpp
+++ b/src/modules/m_spanningtree/main.cpp
@@ -30,8 +30,9 @@
 #include "m_spanningtree/treesocket.h"
 #include "m_spanningtree/rconnect.h"
 #include "m_spanningtree/rsquit.h"
+#include "m_spanningtree/protocolinterface.h"
 
-/* $ModDep: m_spanningtree/timesynctimer.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 */
+/* $ModDep: m_spanningtree/timesynctimer.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)
@@ -56,6 +57,9 @@ ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me)
 	};
 	ServerInstance->Modules->Attach(eventlist, this, 28);
 
+	delete ServerInstance->PI;
+	ServerInstance->PI = new SpanningTreeProtocolInterface(this, Utils, ServerInstance);
+
 	for (std::vector<User*>::const_iterator i = ServerInstance->Users->local_users.begin(); i != ServerInstance->Users->local_users.end(); i++)
 	{
 		this->OnPostConnect((*i));
@@ -990,6 +994,9 @@ void ModuleSpanningTree::OnEvent(Event* event)
 ModuleSpanningTree::~ModuleSpanningTree()
 {
 	/* This will also free the listeners */
+	delete ServerInstance->PI;
+	ServerInstance->PI = new ProtocolInterface(ServerInstance);
+
 	delete Utils;
 
 	ServerInstance->Timers->DelTimer(RefreshTimer);
diff --git a/src/modules/m_spanningtree/protocolinterface.cpp b/src/modules/m_spanningtree/protocolinterface.cpp
new file mode 100644
index 000000000..cf774d603
--- /dev/null
+++ b/src/modules/m_spanningtree/protocolinterface.cpp
@@ -0,0 +1,64 @@
+#include "inspircd.h"
+#include "m_spanningtree/main.h"
+#include "m_spanningtree/utils.h"
+#include "m_spanningtree/protocolinterface.h"
+
+void SpanningTreeProtocolInterface::SendEncapsulatedData(parameterlist &encap)
+{
+	Utils->DoOneToMany(ServerInstance->Config->GetSID(), "ENCAP", encap);
+}
+
+void SpanningTreeProtocolInterface::SendMetaData(void* target, int type, const std::string &key, const std::string &data)
+{
+	parameterlist params;
+
+	switch (type)
+	{
+		case TYPE_USER:
+			params.push_back(((User*)target)->uuid);
+		break;
+		case TYPE_CHANNEL:
+			params.push_back(((Channel*)target)->name);
+		break;
+		case TYPE_SERVER:
+			params.push_back(ServerInstance->Config->GetSID());
+		break;
+	}
+	params.push_back(key);
+	params.push_back(":" + data);
+
+	Utils->DoOneToMany(ServerInstance->Config->GetSID(),"METADATA",params);
+}
+
+void SpanningTreeProtocolInterface::SendTopic(Channel* channel, std::string &topic)
+{
+	parameterlist params;
+
+	params.push_back(channel->name);
+	params.push_back(ConvToStr(ServerInstance->Time()));
+	params.push_back(ServerInstance->Config->ServerName);
+	params.push_back(":" + topic);
+
+	Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FTOPIC", params);
+}
+
+void SpanningTreeProtocolInterface::SendMode(const std::string &origin, const std::string &target, parameterlist &modedata)
+{
+}
+
+void SpanningTreeProtocolInterface::SendOperNotice(const std::string &text)
+{
+}
+
+void SpanningTreeProtocolInterface::SendModeNotice(const std::string &modes, const std::string &text)
+{
+}
+
+void SpanningTreeProtocolInterface::SendSNONotice(const std::string &snomask, const std::string &text)
+{
+}
+
+void SpanningTreeProtocolInterface::PushToClient(User* target, const std::string &rawline)
+{
+}
+
diff --git a/src/modules/m_spanningtree/protocolinterface.h b/src/modules/m_spanningtree/protocolinterface.h
new file mode 100644
index 000000000..568f33463
--- /dev/null
+++ b/src/modules/m_spanningtree/protocolinterface.h
@@ -0,0 +1,26 @@
+#ifndef _SPANNINGTREE_PROTOCOL_INT_
+#define _SPANNINGTREE_PROTOCOL_INT_
+
+class SpanningTreeUtilities;
+class ModuleSpanningTree;
+
+
+class SpanningTreeProtocolInterface : public ProtocolInterface
+{
+	SpanningTreeUtilities* Utils;
+	ModuleSpanningTree* Module;
+ public:
+        SpanningTreeProtocolInterface(ModuleSpanningTree* mod, SpanningTreeUtilities* util, InspIRCd* Instance) : ProtocolInterface(Instance), Utils(util), Module(mod) { }
+        virtual ~SpanningTreeProtocolInterface() { }
+
+        virtual void SendEncapsulatedData(parameterlist &encap);
+        virtual void SendMetaData(void* target, int type, const std::string &key, const std::string &data);
+        virtual void SendTopic(Channel* channel, std::string &topic);
+        virtual void SendMode(const std::string &origin, const std::string &target, parameterlist &modedata);
+        virtual void SendOperNotice(const std::string &text);
+        virtual void SendModeNotice(const std::string &modes, const std::string &text);
+        virtual void SendSNONotice(const std::string &snomask, const std::string &text);
+        virtual void PushToClient(User* target, const std::string &rawline);
+};
+
+#endif