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;
+class Logout : public messages::Logout
+{
+ public:
+	using messages::Logout::Logout;
 
-	void SendEOB() override;
+	void Send(User *u) override;
+};
+
+class ModeUser : public messages::ModeUser
+{
+ public:
+	using messages::ModeUser::ModeUser;
 
-	void SendMode(const MessageSource &source, User *u, const Anope::string &buf) override;
+	void Send(const MessageSource &source, User *user, const Anope::string &modes) override;
+};
+
+class NickIntroduction : public messages::NickIntroduction
+{
+ public:
+	using messages::NickIntroduction::NickIntroduction;
+
+	void Send(User *user) override;
+};
+
+class MessageServer : public messages::MessageServer
+{
+ public:
+	using messages::MessageServer::MessageServer;
+
+	void Send(Server *server) override;
+};
 
-	void SendLogin(User *u, NickServ::Nick *na) override;
+class SGLine : public messages::SGLi