Split ircdproto send functions out into separate services

This makes it easier to see which send functions a protocol module
implements as they are all explicitly registered by the module, and
avoids the problem of subtly breaking other protocol modules when
using inheritance.

Also split the old "core" send implementations out into a module, and
the TS6 ID generator

14 files changed, 1848 insertions, 408 deletions

diff --git a/include/channels.h b/include/channels.h
index d3161b7ae..31fa582c4 100644
--- a/include/channels.h
+++ b/include/channels.h
@@ -70,7 +70,7 @@ class CoreExport Channel : public Base, public Extensible
 	Anope::string topic;
 	/* Who set the topic */
 	Anope::string topic_setter;
-	/* The timestamp associated with the topic. Not necessarually anywhere close to Anope::CurTime.
+	/* The timestamp associated with the topic. Not necessarily anywhere close to Anope::CurTime.
 	 * This is the time the topic was *originally set*. When we restore the topic we want to change the TS back
 	 * to this, but we can only do this on certain IRCds.
 	 */
diff --git a/include/messages.h b/include/messages.h
new file mode 100644
index 000000000..3361d5740
--- /dev/null
+++ b/include/messages.h
@@ -0,0 +1,558 @@
+/*
+ * Anope IRC Services
+ *
+ * Copyright (C) 2016 Anope Team <team@anope.org>
+ *
+ * This file is part of Anope. Anope is free software; you can
+ * redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software
+ * Foundation, version 2.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+template<typename T>
+class MessageSender : public Service
+{
+ public:
+	static constexpr const char *NAME = "messagesender";
+
+	MessageSender(Module *owner) : Service(owner, NAME, T::NAME) { }
+};
+
+namespace messages
+{
+
+class Akill : public MessageSender<Akill>
+{
+ public:
+	static constexpr const char *NAME = "akill";
+
+	using MessageSender::MessageSender;
+
+	/** Sets an akill. This is a recursive function that can be called multiple times
+	 * for the same xline, but for different users, if the xline is not one that can be
+	 * enforced by the IRCd, such as a nick/user/host/realname combination ban.
+	 * @param u The user affected by the akill, if known
+	 * @param x The akill
+	 */
+	virtual void Send(User *, XLine *) anope_abstract;
+};
+
+class AkillDel : public MessageSender<AkillDel>
+{
+ public:
+	static constexpr const char *NAME = "akilldel";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(XLine *) anope_abstract;
+};
+
+class MessageChannel : public MessageSender<MessageChannel>
+{
+ public:
+	static constexpr const char *NAME = "channel";
+
+	using MessageSender::MessageSender;
+
+	/** Send a channel creation message to the uplink.
+	 * On most IRCds this is a SJOIN with no nicks
+	 */
+	virtual void Send(Channel *) anope_abstract;
+};
+
+class GlobalNotice : public MessageSender<GlobalNotice>
+{
+ public:
+	static constexpr const char *NAME = "globalnotice";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const MessageSource &, Server *dest, const Anope::string &msg) anope_abstract;
+};
+
+class GlobalPrivmsg : public MessageSender<GlobalPrivmsg>
+{
+ public:
+	static constexpr const char *NAME = "globalprivmsg";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const MessageSource &, Server *dest, const Anope::string &msg) anope_abstract;
+};
+
+class Invite : public MessageSender<Invite>
+{
+ public:
+	static constexpr const char *NAME = "invite";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const MessageSource &source, Channel *c, User *u) anope_abstract;
+};
+
+class Join : public MessageSender<Join>
+{
+ public:
+	static constexpr const char *NAME = "join";
+
+	using MessageSender::MessageSender;
+
+	/** Joins one of our users to a channel.
+	 * @param u The user to join
+	 * @param c The channel to join the user to
+	 * @param status The status to set on the user after joining. This may or may not already internally
+	 * be set on the user. This may include the modes in the join, but will usually place them on the mode
+	 * stacker to be set "soon".
+	 */
+	virtual void Send(User *u, Channel *c, const ChannelStatus *status) anope_abstract;
+};
+
+class Kick : public MessageSender<Kick>
+{
+ public:
+	static constexpr const char *NAME = "kick";
+
+	using MessageSender::MessageSender;
+
+	/** Kick a user from a channel
+	 * @param source Who is doing the kick
+	 * @param channel Channel
+	 * @param user Target of the kick
+	 * @param reason Kick reason
+	 */
+	virtual void Send(const MessageSource &source, Channel *channel, User *user, const Anope::string &reason) anope_abstract;
+};
+
+class Kill : public MessageSender<Kill>
+{
+ public:
+	static constexpr const char *NAME = "svskill";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const MessageSource &source, const Anope::string &target, const Anope::string &reason) anope_abstract;
+
+	/** Kills a user
+	 * @param source Who is doing the kill
+	 * @param user The target to be killed
+	 * @param reason Kill reason
+	 */
+	virtual void Send(const MessageSource &source, User *user, const Anope::string &reason) anope_abstract;
+};
+
+class Login : public MessageSender<Login>
+{
+ public:
+	static constexpr const char *NAME = "login";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *u, NickServ::Nick *na) anope_abstract;
+};
+
+class Logout : public MessageSender<Logout>
+{
+ public:
+	static constexpr const char *NAME = "logout";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *u) anope_abstract;
+};
+
+class ModeChannel : public MessageSender<ModeChannel>
+{
+ public:
+	static constexpr const char *NAME = "modechannel";
+
+	using MessageSender::MessageSender;
+
+	/** Changes the mode on a channel
+	 * @param source Who is changing the mode
+	 * @param channel Channel
+	 * @param modes Modes eg +nt
+	 */
+	virtual void Send(const MessageSource &source, Channel *channel, const Anope::string &modes) anope_abstract;
+};
+
+class ModeUser : public MessageSender<ModeUser>
+{
+ public:
+	static constexpr const char *NAME = "modeuser";
+
+	using MessageSender::MessageSender;
+
+	/** Changes the mode on a user
+	 * @param source Who is changing the mode
+	 * @param user user
+	 * @param modes Modes eg +i
+	 */
+	virtual void Send(const MessageSource &source, User *user, const Anope::string &modes) anope_abstract;
+};
+
+class NickChange : public MessageSender<NickChange>
+{
+ public:
+	static constexpr const char *NAME = "nickchange";
+
+	using MessageSender::MessageSender;
+
+	/** Sends a nick change of one of our clients.
+	 */
+	virtual void Send(User *u, const Anope::string &newnick, time_t ts) anope_abstract;
+};
+
+class NickIntroduction : public MessageSender<NickIntroduction>
+{
+ public:
+	static constexpr const char *NAME = "nickintroduction";
+
+	using MessageSender::MessageSender;
+
+	/** Introduces a client to the rest of the network
+	 * @param user The client to introduce
+	 */
+	virtual void Send(User *user) anope_abstract;
+};
+
+class NOOP : public MessageSender<NOOP>
+{
+ public:
+	static constexpr const char *NAME = "noop";
+
+	using MessageSender::MessageSender;
+
+	/** Sets the server in NOOP mode. If NOOP mode is enabled, no users
+	 * will be able to oper on the server.
+	 * @param s The server
+	 * @param mode Whether to turn NOOP on or off
+	 */
+	virtual void Send(Server *s, bool mode) anope_abstract;
+};
+
+class Notice : public MessageSender<Notice>
+{
+ public:
+	static constexpr const char *NAME = "notice";
+
+	using MessageSender::MessageSender;
+
+	/** Send a notice to a target
+	 * @param source Source of the notice
+	 * @param dest Destination user/channel
+	 * @param msg Message to send
+	 */
+	virtual void Send(const MessageSource &source, const Anope::string &dest, const Anope::string &msg) anope_abstract;
+};
+
+class Part : public MessageSender<Part>
+{
+ public:
+	static constexpr const char *NAME = "part";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *, Channel *chan, const Anope::string &reason) anope_abstract;
+};
+
+class Ping : public MessageSender<Ping>
+{
+ public:
+	static constexpr const char *NAME = "ping";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const Anope::string &servname, const Anope::string &who) anope_abstract;
+};
+
+class Pong : public MessageSender<Pong>
+{
+ public:
+	static constexpr const char *NAME = "pong";
+
+	using MessageSender::MessageSender;
+
+	/**
+	 * Send a PONG reply to a received PING.
+	 * servname should be left empty to send a one param reply.
+	 * @param servname Daemon or client that is responding to the PING.
+	 * @param who Origin of the PING and destination of the PONG message.
+	 **/
+	virtual void Send(const Anope::string &servname, const Anope::string &who) anope_abstract;
+};
+
+class Privmsg : public MessageSender<Privmsg>
+{
+ public:
+	static constexpr const char *NAME = "privmsg";
+
+	using MessageSender::MessageSender;
+
+	/** Send a privmsg to a target
+	 * @param source Source of the privmsg
+	 * @param dest Destination user/channel
+	 * @param msg Message to send
+	 */
+	virtual void Send(const MessageSource &source, const Anope::string &dest, const Anope::string &msg) anope_abstract;
+};
+
+class Quit : public MessageSender<Quit>
+{
+ public:
+	static constexpr const char *NAME = "quit";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *user, const Anope::string &reason) anope_abstract;
+};
+
+class MessageServer : public MessageSender<MessageServer>
+{
+ public:
+	static constexpr const char *NAME = "server";
+
+	using MessageSender::MessageSender;
+
+	/** Introduces a server to the uplink
+	 */
+	virtual void Send(Server *s) anope_abstract;
+};
+
+class SASL : public MessageSender<SASL>
+{
+ public:
+	static constexpr const char *NAME = "sasl";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const ::SASL::Message &) anope_abstract;
+};
+
+class SASLMechanisms : public MessageSender<SASLMechanisms>
+{
+ public:
+	static constexpr const char *NAME = "saslmechanisms";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const std::vector<Anope::string> &mechanisms) anope_abstract;
+};
+
+// realname ban
+class SGLine : public MessageSender<SGLine>
+{
+ public:
+	static constexpr const char *NAME = "sgline";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *, XLine *) anope_abstract;
+};
+
+class SGLineDel : public MessageSender<SGLineDel>
+{
+ public:
+	static constexpr const char *NAME = "sglinedel";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(XLine *) anope_abstract;
+};
+
+// Nick ban (and sometimes channel)
+class SQLine : public MessageSender<SQLine>
+{
+ public:
+	static constexpr const char *NAME = "sqline";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *, XLine *) anope_abstract;
+};
+
+class SQLineDel : public MessageSender<SQLineDel>
+{
+ public:
+	static constexpr const char *NAME = "sqlinedel";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(XLine *) anope_abstract;
+};
+
+// IP ban
+class SZLine : public MessageSender<SZLine>
+{
+ public:
+	static constexpr const char *NAME = "szline";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *, XLine *) anope_abstract;
+};
+
+class SZLineDel : public MessageSender<SZLineDel>
+{
+ public:
+	static constexpr const char *NAME = "szlinedel";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(XLine *) anope_abstract;
+};
+
+class SQuit : public MessageSender<SQuit>
+{
+ public:
+	static constexpr const char *NAME = "squit";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(Server *s, const Anope::string &message) anope_abstract;
+};
+
+class SVSHold : public MessageSender<SVSHold>
+{
+ public:
+	static constexpr const char *NAME = "svshold";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const Anope::string &, time_t) anope_abstract;
+};
+
+class SVSHoldDel : public MessageSender<SVSHoldDel>
+{
+ public:
+	static constexpr const char *NAME = "svsholddel";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const Anope::string &) anope_abstract;
+};
+
+class SVSJoin : public MessageSender<SVSJoin>
+{
+ public:
+	static constexpr const char *NAME = "svsjoin";
+
+	using MessageSender::MessageSender;
+
+	/** Force joins a user that isn't ours to a channel.
+	 * @param bi The source of the message
+	 * @param u The user to join
+	 * @param chan The channel to join the user to
+	 * @param key Channel key
+	 */
+	virtual void Send(const MessageSource &source, User *u, const Anope::string &chan, const Anope::string &key) anope_abstract;
+};
+
+class SVSNick : public MessageSender<SVSNick>
+{
+ public:
+	static constexpr const char *NAME = "svsnick";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *u, const Anope::string &newnick, time_t ts) anope_abstract;
+};
+
+class SVSPart : public MessageSender<SVSPart>
+{
+ public:
+	static constexpr const char *NAME = "svspart";
+
+	using MessageSender::MessageSender;
+
+	/** Force parts a user that isn't ours from a channel.
+	 * @param source The source of the message
+	 * @param u The user to part
+	 * @param chan The channel to part the user from
+	 * @param param part reason, some IRCds don't support this
+	 */
+	virtual void Send(const MessageSource &source, User *u, const Anope::string &chan, const Anope::string &reason) anope_abstract;
+};
+
+class SVSLogin : public MessageSender<SVSLogin>
+{
+ public:
+	static constexpr const char *NAME = "svslogin";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const Anope::string &uid, const Anope::string &acc, const Anope::string &vident, const Anope::string &vhost) anope_abstract;
+};
+
+class SWhois : public MessageSender<SWhois>
+{
+ public:
+	static constexpr const char *NAME = "swhois";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const MessageSource &, User *user, const Anope::string &) anope_abstract;
+};
+
+class Topic : public MessageSender<Topic>
+{
+ public:
+	static constexpr const char *NAME = "topic";
+
+	using MessageSender::MessageSender;
+
+	/** Sets the topic on a channel
+	 * @param source The bot to set the topic from
+	 * @param chan The channel to set the topic on
+	 * @param topic The new topic
+	 * @param topic_ts The desired time set for the new topic
+	 * @param topic_setter Who set the topic
+	 */
+	virtual void Send(const MessageSource &source, Channel *channel, const Anope::string &topic, time_t topic_ts, const Anope::string &topic_setter) anope_abstract;
+};
+
+class VhostDel : public MessageSender<VhostDel>
+{
+ public:
+	static constexpr const char *NAME = "vhostdel";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(User *u) anope_abstract;
+};
+
+class VhostSet : public MessageSender<VhostSet>
+{
+ public:
+	static constexpr const char *NAME = "vhostset";
+
+	using MessageSender::MessageSender;
+
+	/** Sets a vhost on a user.
+	 * @param u The user
+	 * @param vident The ident to set
+	 * @param vhost The vhost to set
+	 */
+	virtual void Send(User *u, const Anope::string &vident, const Anope::string &vhost) anope_abstract;
+};
+
+class Wallops : public MessageSender<Wallops>
+{
+ public:
+	static constexpr const char *NAME = "wallops";
+
+	using MessageSender::MessageSender;
+
+	virtual void Send(const MessageSource &source, const Anope::string &msg) anope_abstract;
+};
+
+} // namespace messages
diff --git a/include/module.h b/include/module.h
index 58b012fce..66446105a 100644
--- a/include/module.h
+++ b/include/module.h
@@ -32,6 +32,7 @@
 #include "lists.h"
 #include "logger.h"
 #include "mail.h"
+#include "messages.h"
 #include "modes.h"
 #include "modules.h"
 #include "numeric.h"
diff --git a/include/modules/protocol/bahamut.h b/include/modules/protocol/bahamut.h
index f120c7d4c..fd0d47c87 100644
--- a/include/modules/protocol/bahamut.h
+++ b/include/modules/protocol/bahamut.h
@@ -22,62 +22,201 @@
 namespace bahamut
 {
 
-class Proto : public IRCDProto
+namespace senders
+{
+
+class Akill : public messages::Akill
 {
  public:
-	Proto(Module *creator);
+	using messages::Akill::Akill;
 
-	void SendMode(const MessageSource &source, Channel *dest, const Anope::string &buf) override;
+	void Send(User *, XLine *) override;
+};
 
-	void SendMode(const MessageSource &source, User *u, const Anope::string &buf) override;
+class AkillDel : public messages::AkillDel
+{
+ public:
+	using messages::AkillDel::AkillDel;
 
-	void SendGlobalNotice(ServiceBot *bi, Server *dest, const Anope::string &msg) override;
+	void Send(XLine *) override;
+};
+
+class MessageChannel : public messages::MessageChannel
+{
+ public:
+	using messages::MessageChannel::MessageChannel;
+
+	void Send(Channel *) override;
+};
 
-	void SendGlobalPrivmsg(ServiceBot *bi, Server *dest, const Anope::string &msg) override;
+class Join : public messages::Join
+{
+ public:
+	using messages::Join::Join;
+
+	void Send(User *u, Channel *c, const ChannelStatus *status) override;
+};
+
+class Kill : public messages::Kill
+{
+ public:
+	using messages::Kill::Kill;
+
+	void Send(const MessageSource &source, const Anope::string &target, const Anope::string &reason) override;
+
+	void Send(const MessageSource &source, User *user, const Anope::string &reason) override;
+};
+
+class Login : public messages::Login
+{
+ public:
+	using messages::Login::Login;
 
-	void SendSVSHold(const Anope::string &nick, time_t time) override;
+	void Send(User *u, NickServ::Nick *na) override;
+};
 
-	void SendSVSHoldDel(const Anope::string &nick) override;
+class Logout : public messages::Logout
+{
+ public:
+	using messages::Logout::Logout;
 
-	void SendSQLine(User *, XLine *x) override;
+	void Send(User *u) override;
+};
 
-	void SendSGLineDel(XLine *x) override;
+class ModeChannel : public messages::ModeChannel
+{
+ public:
+	using messages::ModeChannel::ModeChannel;
 
-	void SendSZLineDel(XLine *x) override;
+	void Send(const MessageSource &source, Channel *channel, const Anope::string &modes) override;
+};
 
-	void SendSZLine(User *, XLine *x) override;
+class ModeUser : public messages::ModeUser
+{
+ public:
+	using messages::ModeUser::ModeUser;
 
-	void SendSVSNOOP(Server *server, bool set) override;
+	void Send(const MessageSource &source, User *user, const Anope::string &modes) override;
+};
 
-	void SendSGLine(User *, XLine *x) override;
+class NickIntroduction : public messages::NickIntroduction
+{
+ public:
+	using messages::NickIntroduction::NickIntroduction;
 
-	void SendAkillDel(XLine *x) override;
+	void Send(User *user) override;
+};
 
-	void SendTopic(const MessageSource &source, Channel *c) override;
+class NOOP : public messages::NOOP
+{
+ public:
+	static constexpr const char *NAME = "noop";
 
-	void SendSQLineDel(XLine *x) override;
+	using messages::NOOP::NOOP;
 
-	void SendJoin(User *user, Channel *c, const ChannelStatus *status) override;
+	void Send(Server *s, bool mode) override;
+};
 
-	void SendAkill(User *u, XLine *x) override;
+class SGLine : public messages::SGLine
+{
+ public:
+	using messages::SGLine::SGLine;
 
-	void SendSVSKill(const MessageSource &source, User *user, const Anope::string &buf) override;
+	void Send(User *, XLine *) override;
+};
 
-	void SendBOB() override;
+class SGLineDel : public messages::SGLineDel
+{
+ public:
+	using messages::SGLineDel::SGLineDel;
 
-	void SendEOB() override;
+	void Send(XLine *) override;
+};
 
-	void SendClientIntroduction(User *u) override;
+class SQLine : public messages::SQLine
+{
+ public:
+	using messages::SQLine::SQLine;
+
+	void Send(User *, XLine *) override;
+};
+
+class SQLineDel : public messages::SQLineDel
+{
+ public:
+	using messages::SQLineDel::SQLineDel;
+
+	void Send(XLine *) override;
+};
+
+class SZLine : public messages::SZLine
+{
+ public:
+	using messages::SZLine::SZLine;
+
+	void Send(User *, XLine *) override;
+};
+
+class SZLineDel : public messages::SZLineDel
+{
+ public:
+	using messages::SZLineDel::SZLineDel;
+
+	void Send(XLine *) override;
+};
+
+class SVSHold : public messages::SVSHold
+{
+ public:
+	using messages::SVSHold::SVSHold;
+
+	void Send(const Anope::string &, time_t) override;
+};
+
+class SVSHoldDel : public messages::SVSHoldDel
+{
+ public:
+	using messages::SVSHoldDel::SVSHoldDel;
 
-	void SendServer(Server *server) override;
+	void Send(const Anope::string &) override;
+};
 
-	void SendConnect() override;
+class SVSNick : public messages::SVSNick
+{
+ public:
+	using messages::SVSNick::SVSNick;
 
-	void SendChannel(Channel *c) override;
+	void Send(User *u, const Anope::string &newnick, time_t ts) override;
+};
 
-	void SendLogin(User *u, NickServ::Nick *) override;
+class Topic : public messages::Topic
+{
+ public:
+	using messages::Topic::Topic;
+
+	void Send(const MessageSource &source, Channel *channel, const Anope::string &topic, time_t topic_ts, const Anope::string &topic_setter) override;
+};
+
+class Wallops : public messages::Wallops
+{
+ public:
+	using messages::Wallops::Wallops;
+
+	void Send(const MessageSource &source, const Anope::string &msg) override;
+};
+
+} // namespace senders
+
+class Proto : public IRCDProto
+{
+ public:
+	Proto(Module *creator);
+
+	void SendBOB() override;
+
+	void SendEOB() override;
 
-	void SendLogout(User *u) override;
+	void Handshake() override;
 };
 
 class Burst : public IRCDMessage
diff --git a/include/modules/protocol/charybdis.h b/include/modules/protocol/charybdis.h
index ee81a60a1..f3c06bfeb 100644
--- a/include/modules/protocol/charybdis.h
+++ b/include/modules/protocol/charybdis.h
@@ -19,53 +19,91 @@
 
 #pragma once
 
+#include "modules/protocol/ts6.h"
+#include "modules/protocol/ratbox.h"
+
 namespace charybdis
 {
 
-class Proto : public IRCDProto
+namespace senders
 {
-	ServiceReference<IRCDProto> ratbox; // XXX
 
+class NickIntroduction : public messages::NickIntroduction
+{
  public:
-	Proto(Module *creator);
+	using messages::NickIntroduction::NickIntroduction;
 
-	void SendSVSKill(const MessageSource &source, User *targ, const Anope::string &reason) override { ratbox->SendSVSKill(source, targ, reason); }
-	void SendGlobalNotice(ServiceBot *bi, Server *dest, const Anope::string &msg) override { ratbox->SendGlobalNotice(bi, dest, msg); }
-	void SendGlobalPrivmsg(ServiceBot *bi, Server *dest, const Anope::string &msg) override { ratbox->SendGlobalPrivmsg(bi, dest, msg); }
-	void SendGlobops(const MessageSource &source, const Anope::string &buf) override { ratbox->SendGlobops(source, buf); }
-	void SendSGLine(User *u, XLine *x) override { ratbox->SendSGLine(u, x); }
-	void SendSGLineDel(XLine *x) override { ratbox->SendSGLineDel(x); }
-	void SendAkill(User *u, XLine *x) override { ratbox->SendAkill(u, x); }
-	void SendAkillDel(XLine *x) override { ratbox->SendAkillDel(x); }
-	void SendSQLine(User *u, XLine *x) override { ratbox->SendSQLine(u, x); }
-	void SendSQLineDel(XLine *x) override { ratbox->SendSQLineDel(x); }
-	void SendJoin(User *user, Channel *c, const ChannelStatus *status) override { ratbox->SendJoin(user, c, status); }
-	void SendServer(Server *server) override { ratbox->SendServer(server); }
-	void SendChannel(Channel *c) override { ratbox->SendChannel(c); }
-	void SendTopic(const MessageSource &source, Channel *c) override { ratbox->SendTopic(source, c); }
-	bool IsIdentValid(const Anope::string &ident) override { return ratbox->IsIdentValid(ident); }
-	void SendLogin(User *u, NickServ::Nick *na) override { ratbox->SendLogin(u, na); }
-	void SendLogout(User *u) override { ratbox->SendLogout(u); }
+	void Send(User *user) override;
+};
 
-	void SendConnect() override;
+class SASL : public messages::SASL
+{
+ public:
+	using messages::SASL::SASL;
 
-	void SendClientIntroduction(User *u) override;
+	 void Send(const ::SASL::Message &) override;
+};
 
-	void SendForceNickChange(User *u, const Anope::string &newnick, time_t when) override;
+class SASLMechanisms : public messages::SASLMechanisms
+{
+ public:
+	using messages::SASLMechanisms::SASLMechanisms;
 
-	void SendSVSHold(const Anope::string &nick, time_t delay) override;
+	void Send(const std::vector<Anope::string> &mechanisms) override;
+};
 
-	void SendSVSHoldDel(const Anope::string &nick) override;
+class SVSHold : public messages::SVSHold
+{
+ public:
+	using messages::SVSHold::SVSHold;
 
-	void SendVhost(User *u, const Anope::string &ident, const Anope::string &host) override;
+	void Send(const Anope::string &, time_t) override;
+};
 
-	void SendVhostDel(User *u) override;
+class SVSHoldDel : public messages::SVSHoldDel
+{
+ public:
+	using messages::SVSHoldDel::SVSHoldDel;
 
-	void SendSASLMechanisms(std::vector<Anope::string> &mechanisms) override;
+	void Send(const Anope::string &) override;
+};
+
+class SVSLogin : public messages::SVSLogin
+{
+ public:
+	using messages::SVSLogin::SVSLogin;
+
+	void Send(const Anope::string &uid, const Anope::string &acc, const Anope::string &vident, const Anope::string &vhost) override;
+};
+
+class VhostDel : public messages::VhostDel
+{
+ public:
+	using messages::VhostDel::VhostDel;
+
+	void Send(User *u) override;
+};
+
+class VhostSet : public messages::VhostSet
+{
+ public:
+	using messages::VhostSet::VhostSet;
+
+	void Send(User *u, const Anope::string &vident, const Anope::string &vhost) override;
+};
+
+} // namespace senders
+
+class Proto : public ts6::Proto
+{
+	ratbox::Proto ratbox;
+
+ public:
+	Proto(Module *creator);
 
-	void SendSASLMessage(const SASL::Message &message) override;
+	bool IsIdentValid(const Anope::string &ident) override { return ratbox.IsIdentValid(ident); }
 
-	void SendSVSLogin(const Anope::string &uid, const Anope::string &acc, const Anope::string &vident, const Anope::string &vhost) override;
+	void Handshake() override;
 };
 
 class Encap : public IRCDMessage
diff --git a/include/modules/protocol/hybrid.h b/include/modules/protocol/hybrid.h
index a0a9143a8..7843859c0 100644
--- a/include/modules/protocol/hybrid.h
+++ b/include/modules/protocol/hybrid.h
@@ -20,74 +20,242 @@
 #pragma once
 
 #include "modules/protocol/rfc1459.h"
+#include "modules/protocol/ts6.h"
 
 namespace hybrid
 {
 
-class Proto : public IRCDProto
+namespace senders
 {
-	ServiceBot *FindIntroduced();
 
-	void SendSVSKill(const MessageSource &source, User *u, const Anope::string &buf) override;
+class Akill : public messages::Akill
+{
+ public:
+	using messages::Akill::Akill;
 
-  public:
-	Proto(Module *creator);
+	void Send(User *, XLine *) override;
+};
 
-	void SendInvite(const MessageSource &source, Channel *c, User *u) override;
+class AkillDel : public messages::AkillDel
+{
+ public:
+	using messages::AkillDel::AkillDel;
 
-	void SendGlobalNotice(ServiceBot *bi, Server *dest, const Anope::string &msg) override;
+	void Send(XLine *) override;
+};
 
-	void SendGlobalPrivmsg(ServiceBot *bi, Server *dest, const Anope::string &msg) override;
+class MessageChannel : public messages::MessageChannel
+{
+ public:
+	using messages::MessageChannel::MessageChannel;
 
-	void SendSQLine(User *, XLine *x) override;
+	void Send(Channel *) override;
+};
 
-	void SendSGLineDel(XLine *x) override;
+class GlobalNotice : public messages::GlobalNotice
+{
+ public:
+	using messages::GlobalNotice::GlobalNotice;
 
-	void SendSGLine(User *, XLine *x) override;
+	void Send(const MessageSource &, Server *dest, const Anope::string &msg) override;
+};
 
-	void SendSZLineDel(XLine *x) override;
+class GlobalPrivmsg : public messages::GlobalPrivmsg
+{
+ public:
+	using messages::GlobalPrivmsg::GlobalPrivmsg;
 
-	void SendSZLine(User *, XLine *x) override;
+	void Send(const MessageSource &, Server *dest, const Anope::string &msg) override;
+};
 
-	void SendAkillDel(XLine *x) override;
+class Invite : public messages::Invite
+{
+ public:
+	using messages::Invite::Invite;
 
-	void SendSQLineDel(XLine *x) override;
+	void Send(const MessageSource &source, Channel *chan, User *user) override;
+};
 
-	void SendJoin(User *u, Channel *c, const ChannelStatus *status) override;
+class Join : public messages::Join
+{
+ public:
+	using messages::Join::Join;
 
-	void SendAkill(User *u, XLine *x) override;
+	void Send(User *u, Channel *c, const ChannelStatus *status) override;
+};
 
-	void SendServer(Server *server) override;
+class Login : public messages::Login
+{
+ public:
+	using messages::Login::Login;
 
-	void SendConnect() override;
+	void Send(User *u, NickServ::Nick *na) override;
+};
 
-	void SendClientIntroduction(User *u) override;