Rework the RPC modules in preparation for the new JSON-RPC module.

2 files changed, 535 insertions, 0 deletions

diff --git a/modules/rpc/rpc_main.cpp b/modules/rpc/rpc_main.cpp
new file mode 100644
index 000000000..4a87d9e05
--- /dev/null
+++ b/modules/rpc/rpc_main.cpp
@@ -0,0 +1,306 @@
+/*
+ *
+ * (C) 2010-2025 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ */
+
+#include "module.h"
+#include "modules/rpc.h"
+
+static Module *me;
+
+class RPCIdentifyRequest final
+	: public IdentifyRequest
+{
+	RPCRequest request;
+	HTTPReply repl; /* Request holds a reference to the HTTPReply, because we might exist long enough to invalidate it
+	                   we'll copy it here then reset the reference before we use it */
+	Reference<HTTPClient> client;
+	Reference<RPCServiceInterface> xinterface;
+
+public:
+	RPCIdentifyRequest(Module *m, RPCRequest &req, HTTPClient *c, RPCServiceInterface *iface, const Anope::string &acc, const Anope::string &pass) : IdentifyRequest(m, acc, pass), request(req), repl(request.r), client(c), xinterface(iface) { }
+
+	void OnSuccess() override
+	{
+		if (!xinterface || !client)
+			return;
+
+		request.r = this->repl;
+
+		request.reply("result", "Success");
+		request.reply("account", GetAccount());
+
+		xinterface->Reply(request);
+		client->SendReply(&request.r);
+	}
+
+	void OnFail() override
+	{
+		if (!xinterface || !client)
+			return;
+
+		request.r = this->repl;
+
+		request.reply("error", "Invalid password");
+
+		xinterface->Reply(request);
+		client->SendReply(&request.r);
+	}
+};
+
+class MyRPCEvent final
+	: public RPCEvent
+{
+public:
+	bool Run(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request) override
+	{
+		if (request.name == "command")
+			this->DoCommand(iface, client, request);
+		else if (request.name == "checkAuthentication")
+			return this->DoCheckAuthentication(iface, client, request);
+		else if (request.name == "stats")
+			this->DoStats(iface, client, request);
+		else if (request.name == "channel")
+			this->DoChannel(iface, client, request);
+		else if (request.name == "user")
+			this->DoUser(iface, client, request);
+		else if (request.name == "opers")
+			this->DoOperType(iface, client, request);
+		else if (request.name == "notice")
+			this->DoNotice(iface, client, request);
+
+		return true;
+	}
+
+private:
+	void DoCommand(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request)
+	{
+		Anope::string service = request.data.size() > 0 ? request.data[0] : "";
+		Anope::string user = request.data.size() > 1 ? request.data[1] : "";
+		Anope::string command = request.data.size() > 2 ? request.data[2] : "";
+
+		if (service.empty() || user.empty() || command.empty())
+			request.reply("error", "Invalid parameters");
+		else
+		{
+			BotInfo *bi = BotInfo::Find(service, true);
+			if (!bi)
+				request.reply("error", "Invalid service");
+			else
+			{
+				request.reply("result", "Success");
+
+				NickAlias *na = NickAlias::Find(user);
+
+				Anope::string out;
+
+				struct RPCommandReply final
+					: CommandReply
+				{
+					Anope::string &str;
+
+					RPCommandReply(Anope::string &s) : str(s) { }
+
+					void SendMessage(BotInfo *source, const Anope::string &msg) override
+					{
+						str += msg + "\n";
+					};
+				}
+				reply(out);
+
+				User *u = User::Find(user, true);
+				CommandSource source(user, u, na ? *na->nc : NULL, &reply, bi);
+				Command::Run(source, command);
+
+				if (!out.empty())
+					request.reply("return", iface->Sanitize(out));
+			}
+		}
+	}
+
+	static bool DoCheckAuthentication(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request)
+	{
+		Anope::string username = request.data.size() > 0 ? request.data[0] : "";
+		Anope::string password = request.data.size() > 1 ? request.data[1] : "";
+
+		if (username.empty() || password.empty())
+			request.reply("error", "Invalid parameters");
+		else
+		{
+			auto *req = new RPCIdentifyRequest(me, request, client, iface, username, password);
+			FOREACH_MOD(OnCheckAuthentication, (NULL, req));
+			req->Dispatch();
+			return false;
+		}
+
+		return true;
+	}
+
+	static void DoStats(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request)
+	{
+		request.reply("uptime", Anope::ToString(Anope::CurTime - Anope::StartTime));
+		request.reply("uplinkname", Me->GetLinks().front()->GetName());
+		{
+			Anope::string buf;
+			for (const auto &capab : Servers::Capab)
+				buf += " " + capab;
+			if (!buf.empty())
+				buf.erase(buf.begin());
+			request.reply("uplinkcapab", buf);
+		}
+		request.reply("usercount", Anope::ToString(UserListByNick.size()));
+		request.reply("maxusercount", Anope::ToString(MaxUserCount));
+		request.reply("channelcount", Anope::ToString(ChannelList.size()));
+	}
+
+	static void DoChannel(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request)
+	{
+		if (request.data.empty())
+			return;
+
+		Channel *c = Channel::Find(request.data[0]);
+
+		request.reply("name", iface->Sanitize(c ? c->name : request.data[0]));
+
+		if (c)
+		{
+			request.reply("bancount", Anope::ToString(c->HasMode("BAN")));
+			int count = 0;
+			for (auto &ban : c->GetModeList("BAN"))
+				request.reply("ban" + Anope::ToString(++count), iface->Sanitize(ban));
+
+			request.reply("exceptcount", Anope::ToString(c->HasMode("EXCEPT")));
+			count = 0;
+			for (auto &except : c->GetModeList("EXCEPT"))
+				request.reply("except" + Anope::ToString(++count), iface->Sanitize(except));
+
+			request.reply("invitecount", Anope::ToString(c->HasMode("INVITEOVERRIDE")));
+			count = 0;
+			for (auto &invite : c->GetModeList("INVITEOVERRIDE"))
+				request.reply("invite" + Anope::ToString(++count), iface->Sanitize(invite));
+
+			Anope::string users;
+			for (Channel::ChanUserList::const_iterator it = c->users.begin(); it != c->users.end(); ++it)
+			{
+				ChanUserContainer *uc = it->second;
+				users += uc->status.BuildModePrefixList() + uc->user->nick + " ";
+			}
+			if (!users.empty())
+			{
+				users.erase(users.length() - 1);
+				request.reply("users", iface->Sanitize(users));
+			}
+
+			if (!c->topic.empty())
+				request.reply("topic", iface->Sanitize(c->topic));
+
+			if (!c->topic_setter.empty())
+				request.reply("topicsetter", iface->Sanitize(c->topic_setter));
+
+			request.reply("topictime", Anope::ToString(c->topic_time));
+			request.reply("topicts", Anope::ToString(c->topic_ts));
+		}
+	}
+
+	static void DoUser(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request)
+	{
+		if (request.data.empty())
+			return;
+
+		User *u = User::Find(request.data[0]);
+
+		request.reply("nick", iface->Sanitize(u ? u->nick : request.data[0]));
+
+		if (u)
+		{
+			request.reply("ident", iface->Sanitize(u->GetIdent()));
+			request.reply("vident", iface->Sanitize(u->GetVIdent()));
+			request.reply("host", iface->Sanitize(u->host));
+			if (!u->vhost.empty())
+				request.reply("vhost", iface->Sanitize(u->vhost));
+			if (!u->chost.empty())
+				request.reply("chost", iface->Sanitize(u->chost));
+			request.reply("ip", u->ip.addr());
+			request.reply("timestamp", Anope::ToString(u->timestamp));
+			request.reply("signon", Anope::ToString(u->signon));
+			if (u->IsIdentified())
+			{
+				request.reply("account", iface->Sanitize(u->Account()->display));
+				if (u->Account()->o)
+					request.reply("opertype", iface->Sanitize(u->Account()->o->ot->GetName()));
+			}
+
+			Anope::string channels;
+			for (User::ChanUserList::const_iterator it = u->chans.begin(); it != u->chans.end(); ++it)
+			{
+				ChanUserContainer *cc = it->second;
+				channels += cc->status.BuildModePrefixList() + cc->chan->name + " ";
+			}
+			if (!channels.empty())
+			{
+				channels.erase(channels.length() - 1);
+				request.reply("channels", channels);
+			}
+		}
+	}
+
+	static void DoOperType(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request)
+	{
+		for (auto *ot : Config->MyOperTypes)
+		{
+			Anope::string perms;
+			for (const auto &priv : ot->GetPrivs())
+				perms += " " + priv;
+			for (const auto &command : ot->GetCommands())
+				perms += " " + command;
+			request.reply(ot->GetName(), perms);
+		}
+	}
+
+	static void DoNotice(RPCServiceInterface *iface, HTTPClient *client, RPCRequest &request)
+	{
+		Anope::string from = request.data.size() > 0 ? request.data[0] : "";
+		Anope::string to = request.data.size() > 1 ? request.data[1] : "";
+		Anope::string message = request.data.size() > 2 ? request.data[2] : "";
+
+		BotInfo *bi = BotInfo::Find(from, true);
+		User *u = User::Find(to, true);
+
+		if (!bi || !u || message.empty())
+			return;
+
+		u->SendMessage(bi, message);
+
+		request.reply("result", "Success");
+	}
+};
+
+class ModuleRPCMain final
+	: public Module
+{
+	ServiceReference<RPCServiceInterface> rpc;
+
+	MyRPCEvent stats;
+
+public:
+	ModuleRPCMain(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, EXTRA | VENDOR), rpc("RPCServiceInterface", "rpc")
+	{
+		me = this;
+
+		if (!rpc)
+			throw ModuleException("Unable to find RPC interface, is xmlrpc loaded?");
+
+		rpc->Register(&stats);
+	}
+
+	~ModuleRPCMain() override
+	{
+		if (rpc)
+			rpc->Unregister(&stats);
+	}
+};
+
+MODULE_INIT(ModuleRPCMain)
diff --git a/modules/rpc/xmlrpc.cpp b/modules/rpc/xmlrpc.cpp
new file mode 100644
index 000000000..f1db6efba
--- /dev/null
+++ b/modules/rpc/xmlrpc.cpp
@@ -0,0 +1,229 @@
+/*
+ *
+ * (C) 2010-2025 Anope Team
+ * Contact us at team@anope.org
+ *
+ * Please read COPYING and README for further details.
+ */
+
+#include "module.h"
+#include "modules/rpc.h"
+#include "modules/httpd.h"
+
+static struct special_chars final
+{
+	Anope::string character;
+	Anope::string replace;
+
+	special_chars(const Anope::string &c, const Anope::string &r) : character(c), replace(r) { }
+}
+special[] = {
+	special_chars("&", "&amp;"),
+	special_chars("\"", "&quot;"),
+	special_chars("<", "&lt;"),
+	special_chars(">", "&qt;"),
+	special_chars("'", "&#39;"),
+	special_chars("\n", "&#xA;"),
+	special_chars("\002", ""), // bold
+	special_chars("\003", ""), // color
+	special_chars("\035", ""), // italics
+	special_chars("\037", ""), // underline
+	special_chars("\026", ""), // reverses
+	special_chars("", "")
+};
+
+class MyXMLRPCServiceInterface final
+	: public RPCServiceInterface
+	, public HTTPPage
+{
+	std::deque<RPCEvent *> events;
+
+public:
+	MyXMLRPCServiceInterface(Module *creator, const Anope::string &sname) : RPCServiceInterface(creator, sname), HTTPPage("/xmlrpc", "text/xml") { }
+
+	void Register(RPCEvent *event) override
+	{
+		this->events.push_back(event);
+	}
+
+	void Unregister(RPCEvent *event) override
+	{
+		std::deque<RPCEvent *>::iterator it = std::find(this->events.begin(), this->events.end(), event);
+
+		if (it != this->events.end())
+			this->events.erase(it);
+	}
+
+	Anope::string Sanitize(const Anope::string &string) override
+	{
+		Anope::string ret = string;
+		for (int i = 0; !special[i].character.empty(); ++i)
+			ret = ret.replace_all_cs(special[i].character, special[i].replace);
+		return ret;
+	}
+
+	static Anope::string Unescape(const Anope::string &string)
+	{
+		Anope::string ret = string;
+		for (int i = 0; !special[i].character.empty(); ++i)
+			if (!special[i].replace.empty())
+				ret = ret.replace_all_cs(special[i].replace, special[i].character);
+
+		for (size_t i, last = 0; (i = string.find("&#", last)) != Anope::string::npos;)
+		{
+			last = i + 1;
+
+			size_t end = string.find(';', i);
+			if (end == Anope::string::npos)
+				break;
+
+			Anope::string ch = string.substr(i + 2, end - (i + 2));
+
+			if (ch.empty())
+				continue;
+
+			long l;
+			if (!ch.empty() && ch[0] == 'x')
+				l = strtol(ch.substr(1).c_str(), NULL, 16);
+			else
+				l = strtol(ch.c_str(), NULL, 10);
+
+			if (l > 0 && l < 256)
+				ret = ret.replace_all_cs("&#" + ch + ";", Anope::string(l));
+		}
+
+		return ret;
+	}
+
+private:
+	static bool GetData(Anope::string &content, Anope::string &tag, Anope::string &data)
+	{
+		if (content.empty())
+			return false;
+
+		Anope::string prev, cur;
+		bool istag;
+
+		do
+		{
+			prev = cur;
+			cur.clear();
+
+			size_t len = 0;
+			istag = false;
+
+			if (content[0] == '<')
+			{
+				len = content.find_first_of('>');
+				istag = true;
+			}
+			else if (content[0] != '>')
+			{
+				len = content.find_first_of('<');
+			}
+
+			// len must advance
+			if (len == Anope::string::npos || len == 0)
+				break;
+
+			if (istag)
+			{
+				cur = content.substr(1, len - 1);
+				content.erase(0, len + 1);
+				while (!content.empty() && content[0] == ' ')
+					content.erase(content.begin());
+			}
+			else
+			{
+				cur = content.substr(0, len);
+				content.erase(0, len);
+			}
+		}
+		while (istag && !content.empty());
+
+		tag = Unescape(prev);
+		data = Unescape(cur);
+		return !istag && !data.empty();
+	}
+
+public:
+	bool OnRequest(HTTPProvider *provider, const Anope::string &page_name, HTTPClient *client, HTTPMessage &message, HTTPReply &reply) override
+	{
+		Anope::string content = message.content, tname, data;
+		RPCRequest request(reply);
+
+		while (GetData(content, tname, data))
+		{
+			Log(LOG_DEBUG) << "xmlrpc: Tag name: " << tname << ", data: " << data;
+			if (tname == "methodName")
+				request.name = data;
+			else if (tname == "name" && data == "id")
+			{
+				GetData(content, tname, data);
+				request.id = data;
+			}
+			else if (tname == "string")
+				request.data.push_back(data);
+		}
+
+		for (auto *e : this->events)
+		{
+			if (!e->Run(this, client, request))
+				return false;
+			else if (!request.get_replies().empty())
+			{
+				this->Reply(request);
+				return true;
+			}
+		}
+
+		reply.error = HTTP_PAGE_NOT_FOUND;
+		reply.Write("Unrecognized query");
+		return true;
+	}
+
+	void Reply(RPCRequest &request) override
+	{
+		if (!request.id.empty())
+			request.reply("id", request.id);
+
+		Anope::string r = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n<methodResponse>\n<params>\n<param>\n<value>\n<struct>\n";
+		for (const auto &[name, value] : request.get_replies())
+			r += "<member>\n<name>" + name + "</name>\n<value>\n<string>" + this->Sanitize(value) + "</string>\n</value>\n</member>\n";
+		r += "</struct>\n</value>\n</param>\n</params>\n</methodResponse>";
+
+		request.r.Write(r);
+	}
+};
+
+class ModuleXMLRPC final
+	: public Module
+{
+	ServiceReference<HTTPProvider> httpref;
+public:
+	MyXMLRPCServiceInterface xmlrpcinterface;
+
+	ModuleXMLRPC(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, EXTRA | VENDOR),
+		xmlrpcinterface(this, "rpc")
+	{
+
+	}
+
+	~ModuleXMLRPC() override
+	{
+		if (httpref)
+			httpref->UnregisterPage(&xmlrpcinterface);
+	}
+
+	void OnReload(Configuration::Conf *conf) override
+	{
+		if (httpref)
+			httpref->UnregisterPage(&xmlrpcinterface);
+		this->httpref = ServiceReference<HTTPProvider>("HTTPProvider", conf->GetModule(this)->Get<const Anope::string>("server", "httpd/main"));
+		if (!httpref)
+			throw ConfigException("Unable to find http reference, is httpd loaded?");
+		httpref->RegisterPage(&xmlrpcinterface);
+	}
+};
+
+MODULE_INIT(ModuleXMLRPC)