X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_callerid.cpp;h=2f47912aee76d0064972f9dae73599a925c60bfa;hb=80e81e3b81b779901fd9d67f8ae030ee30c0bcec;hp=7fea35d348638c86af47e7f97311bc6e9cb82d5a;hpb=dd98d56cabcd08a3d5207454e002b187af98d28a;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_callerid.cpp b/src/modules/m_callerid.cpp
index 7fea35d34..2f47912ae 100644
--- a/src/modules/m_callerid.cpp
+++ b/src/modules/m_callerid.cpp
@@ -1,355 +1,476 @@
-#include "inspircd.h"
-#include "users.h"
-#include "channels.h"
-#include "modules.h"
+/*
+ * InspIRCd -- Internet Relay Chat Daemon
+ *
+ *   Copyright (C) 2013, 2017-2019 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2013 Adam <Adam@anope.org>
+ *   Copyright (C) 2012-2016 Attila Molnar <attilamolnar@hush.com>
+ *   Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be>
+ *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
+ *   Copyright (C) 2009 Uli Schlachter <psychon@inspircd.org>
+ *   Copyright (C) 2009 John Brooks <special@inspircd.org>
+ *   Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net>
+ *   Copyright (C) 2008, 2010 Craig Edwards <brain@inspircd.org>
+ *   Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
+ *
+ * This file is part of InspIRCd.  InspIRCd 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 <http://www.gnu.org/licenses/>.
+ */
+
 
-#include <set>
+#include "inspircd.h"
+#include "modules/callerid.h"
+#include "modules/ctctags.h"
 
-/* $ModDesc: Implementation of callerid (umode +g & /accept, ala hybrid etc) */
+enum
+{
+	RPL_ACCEPTLIST = 281,
+	RPL_ENDOFACCEPT = 282,
+	ERR_ACCEPTFULL = 456,
+	ERR_ACCEPTEXIST = 457,
+	ERR_ACCEPTNOT = 458,
+	ERR_TARGUMODEG = 716,
+	RPL_TARGNOTIFY = 717,
+	RPL_UMODEGMSG = 718
+};
 
 class callerid_data
 {
  public:
+ 	typedef insp::flat_set<User*> UserSet;
+	typedef std::vector<callerid_data*> CallerIdDataSet;
+
 	time_t lastnotify;
-	std::set<User*> accepting;
+
+	/** Users I accept messages from
+	 */
+	UserSet accepting;
+
+	/** Users who list me as accepted
+	 */
+	CallerIdDataSet wholistsme;
+
+	callerid_data() : lastnotify(0) { }
+
+	std::string ToString(bool human) const
+	{
+		std::ostringstream oss;
+		oss << lastnotify;
+		for (UserSet::const_iterator i = accepting.begin(); i != accepting.end(); ++i)
+		{
+			User* u = *i;
+			if (human)
+				oss << ' ' << u->nick;
+			else
+				oss << ',' << u->uuid;
+		}
+		return oss.str();
+	}
 };
 
-callerid_data* GetData(User* who, bool extend = true)
+struct CallerIDExtInfo : public ExtensionItem
 {
-	callerid_data* dat;
-	if (who->GetExt("callerid_data", dat))
+	CallerIDExtInfo(Module* parent)
+		: ExtensionItem("callerid_data", ExtensionItem::EXT_USER, parent)
 	{
-		return dat;
 	}
-	else
+
+	std::string ToHuman(const Extensible* container, void* item) const CXX11_OVERRIDE
+	{
+		callerid_data* dat = static_cast<callerid_data*>(item);
+		return dat->ToString(true);
+	}
+
+	std::string ToInternal(const Extensible* container, void* item) const CXX11_OVERRIDE
+	{
+		callerid_data* dat = static_cast<callerid_data*>(item);
+		return dat->ToString(false);
+	}
+
+	void FromInternal(Extensible* container, const std::string& value) CXX11_OVERRIDE
 	{
-		if (extend)
+		void* old = get_raw(container);
+		if (old)
+			this->free(NULL, old);
+		callerid_data* dat = new callerid_data;
+		set_raw(container, dat);
+
+		irc::commasepstream s(value);
+		std::string tok;
+		if (s.GetToken(tok))
+			dat->lastnotify = ConvToNum<time_t>(tok);
+
+		while (s.GetToken(tok))
 		{
-			dat = new callerid_data;
-			dat->lastnotify = 0; // Can't init in struct.
-			who->Extend("callerid_data", dat);
-			return dat;
+			User *u = ServerInstance->FindNick(tok);
+			if ((u) && (u->registered == REG_ALL) && (!u->quitting))
+			{
+				if (dat->accepting.insert(u).second)
+				{
+					callerid_data* other = this->get(u, true);
+					other->wholistsme.push_back(dat);
+				}
+			}
 		}
-		else
+	}
+
+	callerid_data* get(User* user, bool create)
+	{
+		callerid_data* dat = static_cast<callerid_data*>(get_raw(user));
+		if (create && !dat)
 		{
-			return NULL;
+			dat = new callerid_data;
+			set_raw(user, dat);
 		}
+		return dat;
 	}
-}
 
-void RemoveData(User* who)
-{
-	callerid_data* dat;
-	who->GetExt("callerid_data", dat);
-	if (!dat) return;
-	who->Shrink("callerid_data");
-	delete dat;
-}
-
-void RemoveFromAllAccepts(InspIRCd* ServerInstance, User* who)
-{
-	for (user_hash::iterator i = ServerInstance->Users->clientlist->begin(); i != ServerInstance->Users->clientlist->end(); ++i)
+	void free(Extensible* container, void* item) CXX11_OVERRIDE
 	{
-		callerid_data* dat = GetData(i->second, false);
-		if (!dat) continue;
-		std::set<User*>& accepting = dat->accepting;
-		std::set<User*>::iterator iter = accepting.find(who);
-		if (iter == accepting.end()) continue;
-		accepting.erase(iter);
-	}
-}
+		callerid_data* dat = static_cast<callerid_data*>(item);
 
-class User_g : public ModeHandler
-{
-private:
+		// We need to walk the list of users on our accept list, and remove ourselves from their wholistsme.
+		for (callerid_data::UserSet::iterator it = dat->accepting.begin(); it != dat->accepting.end(); ++it)
+		{
+			callerid_data *targ = this->get(*it, false);
 
-public:
-	User_g(InspIRCd* Instance) : ModeHandler(Instance, 'g', 0, 0, false, MODETYPE_USER, false) { }
+			if (!targ)
+			{
+				ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "ERROR: Inconsistency detected in callerid state, please report (1)");
+				continue; // shouldn't happen, but oh well.
+			}
 
-	ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
-	{
-		if (adding != dest->IsModeSet('g'))
-		{
-			dest->SetMode('g', adding);
-			return MODEACTION_ALLOW;
+			if (!stdalgo::vector::swaperase(targ->wholistsme, dat))
+				ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "ERROR: Inconsistency detected in callerid state, please report (2)");
 		}
-		return MODEACTION_DENY;
+		delete dat;
 	}
 };
 
 class CommandAccept : public Command
 {
-private:
-	unsigned int& maxaccepts;
+	/** Pair: first is the target, second is true to add, false to remove
+	 */
+	typedef std::pair<User*, bool> ACCEPTAction;
+
+	static ACCEPTAction GetTargetAndAction(std::string& tok, User* cmdfrom = NULL)
+	{
+		bool remove = (tok[0] == '-');
+		if ((remove) || (tok[0] == '+'))
+			tok.erase(tok.begin());
+
+		User* target;
+		if (!cmdfrom || !IS_LOCAL(cmdfrom))
+			target = ServerInstance->FindNick(tok);
+		else
+			target = ServerInstance->FindNickOnly(tok);
+
+		if ((!target) || (target->registered != REG_ALL) || (target->quitting))
+			target = NULL;
+
+		return std::make_pair(target, !remove);
+	}
+
 public:
-	CommandAccept(InspIRCd* Instance, unsigned int& max) : Command(Instance, "ACCEPT", 0, 1), maxaccepts(max)
+	CallerIDExtInfo extInfo;
+	unsigned int maxaccepts;
+	CommandAccept(Module* Creator) : Command(Creator, "ACCEPT", 1),
+		extInfo(Creator)
 	{
-		source = "m_callerid.so";
-		syntax = "{[+|-]<nicks>}|*}";
+		allow_empty_last_param = false;
+		syntax = "*|(+|-)<nick>[,(+|-)<nick>]+";
+		TRANSLATE1(TR_CUSTOM);
 	}
 
-	/* Will take any number of nicks, which can be seperated by spaces, commas, or a mix.
+	void EncodeParameter(std::string& parameter, unsigned int index) CXX11_OVERRIDE
+	{
+		// Send lists as-is (part of 2.0 compat)
+		if (parameter.find(',') != std::string::npos)
+			return;
+
+		// Convert a (+|-)<nick> into a [-]<uuid>
+		ACCEPTAction action = GetTargetAndAction(parameter);
+		if (!action.first)
+			return;
+
+		parameter = (action.second ? "" : "-") + action.first->uuid;
+	}
+
+	/** Will take any number of nicks (up to MaxTargets), which can be separated by commas.
 	 * - in front of any nick removes, and an * lists. This effectively means you can do:
-	 * /accept nick1,nick2,nick3 *
+	 * /accept nick1,nick2,nick3,*
 	 * to add 3 nicks and then show your list
 	 */
-	CmdResult Handle(const char** parameters, int pcnt, User* user)
+	CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
 	{
-		if (pcnt < 1)
-		{
-			/* Command stuff should've dealt with this already */
-			return CMD_FAILURE;
-		}
+		if (CommandParser::LoopCall(user, this, parameters, 0))
+			return CMD_SUCCESS;
+
 		/* Even if callerid mode is not set, we let them manage their ACCEPT list so that if they go +g they can
 		 * have a list already setup. */
-		bool atleastonechange = false;
-		for (int i = 0; i < pcnt; ++i)
+
+		if (parameters[0] == "*")
 		{
-			const char* arg = parameters[i];
-			irc::commasepstream css(arg);
-			std::string tok;
-			while (css.GetToken(tok))
-			{
-				if (tok.length() < 1)
-					continue;
-				if (tok == "*")
-				{
-					if (IS_LOCAL(user)) continue;
-					ListAccept(user);
-				}
-				else if (tok[0] == '-')
-				{
-					User* whotoremove = ServerInstance->FindNick(tok.substr(1));
-					if (whotoremove)
-					{
-						atleastonechange = RemoveAccept(user, whotoremove, false) || atleastonechange;
-					}
-				}
-				else
-				{
-					User* whotoadd = ServerInstance->FindNick(tok[0] == '+' ? tok.substr(1) : tok);
-					if (whotoadd)
-					{
-						atleastonechange = AddAccept(user, whotoadd, false) || atleastonechange;
-					}
-					else
-					{
-						user->WriteServ("401 %s %s :No such nick/channel", user->nick, tok.c_str());
-					}
-				}
-			}
+			ListAccept(user);
+			return CMD_SUCCESS;
+		}
+
+		std::string tok = parameters[0];
+		ACCEPTAction action = GetTargetAndAction(tok, user);
+		if (!action.first)
+		{
+			user->WriteNumeric(Numerics::NoSuchNick(tok));
+			return CMD_FAILURE;
 		}
-		return atleastonechange ? CMD_FAILURE : CMD_SUCCESS;
+
+		if ((!IS_LOCAL(user)) && (!IS_LOCAL(action.first)))
+			// Neither source nor target is local, forward the command to the server of target
+			return CMD_SUCCESS;
+
+		// The second item in the pair is true if the first char is a '+' (or nothing), false if it's a '-'
+		if (action.second)
+			return (AddAccept(user, action.first) ? CMD_SUCCESS : CMD_FAILURE);
+		else
+			return (RemoveAccept(user, action.first) ? CMD_SUCCESS : CMD_FAILURE);
+	}
+
+	RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
+	{
+		// There is a list in parameters[0] in two cases:
+		// Either when the source is remote, this happens because 2.0 servers send comma separated uuid lists,
+		// we don't split those but broadcast them, as before.
+		//
+		// Or if the source is local then LoopCall() runs OnPostCommand() after each entry in the list,
+		// meaning the linking module has sent an ACCEPT already for each entry in the list to the
+		// appropriate server and the ACCEPT with the list of nicks (this) doesn't need to be sent anywhere.
+		if ((!IS_LOCAL(user)) && (parameters[0].find(',') != std::string::npos))
+			return ROUTE_BROADCAST;
+
+		// Find the target
+		std::string targetstring = parameters[0];
+		ACCEPTAction action = GetTargetAndAction(targetstring, user);
+		if (!action.first)
+			// Target is a "*" or source is local and the target is a list of nicks
+			return ROUTE_LOCALONLY;
+
+		// Route to the server of the target
+		return ROUTE_UNICAST(action.first->server);
 	}
 
 	void ListAccept(User* user)
 	{
-		callerid_data* dat = GetData(user, false);
+		callerid_data* dat = extInfo.get(user, false);
 		if (dat)
 		{
-			for (std::set<User*>::iterator i = dat->accepting.begin(); i != dat->accepting.end(); ++i)
-			{
-				user->WriteServ("281 %s %s", user->nick, (*i)->nick);
-			}
+			for (callerid_data::UserSet::iterator i = dat->accepting.begin(); i != dat->accepting.end(); ++i)
+				user->WriteNumeric(RPL_ACCEPTLIST, (*i)->nick);
 		}
-		user->WriteServ("282 %s :End of ACCEPT list", user->nick);
+		user->WriteNumeric(RPL_ENDOFACCEPT, "End of ACCEPT list");
 	}
 
-	bool AddAccept(User* user, User* whotoadd, bool quiet)
+	bool AddAccept(User* user, User* whotoadd)
 	{
-		callerid_data* dat = GetData(user, true);
-		std::set<User*>& accepting = dat->accepting;
-		if (accepting.size() >= maxaccepts)
+		// Add this user to my accept list first, so look me up..
+		callerid_data* dat = extInfo.get(user, true);
+		if (dat->accepting.size() >= maxaccepts)
 		{
-			if (!quiet) user->WriteServ("456 %s :Accept list is full (limit is %d)", user->nick, maxaccepts);
+			user->WriteNumeric(ERR_ACCEPTFULL, InspIRCd::Format("Accept list is full (limit is %d)", maxaccepts));
 			return false;
 		}
-		if (!accepting.insert(whotoadd).second)
+		if (!dat->accepting.insert(whotoadd).second)
 		{
-			if (!quiet) user->WriteServ("457 %s %s :is already on your accept list", user->nick, whotoadd->nick);
+			user->WriteNumeric(ERR_ACCEPTEXIST, whotoadd->nick, "is already on your accept list");
 			return false;
 		}
+
+		// Now, look them up, and add me to their list
+		callerid_data *targ = extInfo.get(whotoadd, true);
+		targ->wholistsme.push_back(dat);
+
+		user->WriteNotice(whotoadd->nick + " is now on your accept list");
 		return true;
 	}
 
-	bool RemoveAccept(User* user, User* whotoremove, bool quiet)
+	bool RemoveAccept(User* user, User* whotoremove)
 	{
-		callerid_data* dat = GetData(user, false);
+		// Remove them from my list, so look up my list..
+		callerid_data* dat = extInfo.get(user, false);
 		if (!dat)
 		{
-			if (!quiet) user->WriteServ("458 %s %s :is not on your accept list", user->nick, whotoremove->nick);
+			user->WriteNumeric(ERR_ACCEPTNOT, whotoremove->nick, "is not on your accept list");
+			return false;
+		}
+		if (!dat->accepting.erase(whotoremove))
+		{
+			user->WriteNumeric(ERR_ACCEPTNOT, whotoremove->nick, "is not on your accept list");
 			return false;
 		}
-		std::set<User*>& accepting = dat->accepting;
-		std::set<User*>::iterator i = accepting.find(whotoremove);
-		if (i == accepting.end())
+
+		// Look up their list to remove me.
+		callerid_data *dat2 = extInfo.get(whotoremove, false);
+		if (!dat2)
 		{
-			if (!quiet) user->WriteServ("458 %s %s :is not on your accept list", user->nick, whotoremove->nick);
+			// How the fuck is this possible.
+			ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "ERROR: Inconsistency detected in callerid state, please report (3)");
 			return false;
 		}
-		accepting.erase(i);
+
+		if (!stdalgo::vector::swaperase(dat2->wholistsme, dat))
+			ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "ERROR: Inconsistency detected in callerid state, please report (4)");
+
+
+		user->WriteNotice(whotoremove->nick + " is no longer on your accept list");
 		return true;
 	}
 };
 
-class ModuleCallerID : public Module
+class CallerIDAPIImpl : public CallerID::APIBase
+{
+ private:
+	CallerIDExtInfo& ext;
+
+ public:
+	CallerIDAPIImpl(Module* Creator, CallerIDExtInfo& Ext)
+		: CallerID::APIBase(Creator)
+		, ext(Ext)
+	{
+	}
+
+	bool IsOnAcceptList(User* source, User* target) CXX11_OVERRIDE
+	{
+		callerid_data* dat = ext.get(target, true);
+		return dat->accepting.count(source);
+	}
+};
+
+
+class ModuleCallerID
+	: public Module
+	, public CTCTags::EventListener
 {
-private:
-	CommandAccept *mycommand;
-	User_g* myumode;
+	CommandAccept cmd;
+	CallerIDAPIImpl api;
+	SimpleUserModeHandler myumode;
 
 	// Configuration variables:
-	unsigned int maxaccepts; // Maximum ACCEPT entries.
-	bool operoverride; // Operators can override callerid.
 	bool tracknick; // Allow ACCEPT entries to update with nick changes.
 	unsigned int notify_cooldown; // Seconds between notifications.
 
-public:
-	ModuleCallerID(InspIRCd* Me) : Module(Me)
+	/** Removes a user from all accept lists
+	 * @param who The user to remove from accepts
+	 */
+	void RemoveFromAllAccepts(User* who)
 	{
-		OnRehash(NULL, "");
-		mycommand = new CommandAccept(ServerInstance, maxaccepts);
-		myumode = new User_g(ServerInstance);
-		try {
-			ServerInstance->AddCommand(mycommand);
-		} catch (const ModuleException& e) {
-			delete mycommand;
-			throw;
-		}
-		if (!ServerInstance->Modes->AddMode(myumode))
+		// First, find the list of people who have me on accept
+		callerid_data *userdata = cmd.extInfo.get(who, false);
+		if (!userdata)
+			return;
+
+		// Iterate over the list of people who accept me, and remove all entries
+		for (callerid_data::CallerIdDataSet::iterator it = userdata->wholistsme.begin(); it != userdata->wholistsme.end(); ++it)
 		{
-			delete mycommand;
-			delete myumode;
-			throw new ModuleException("Could not add usermode and command!");
+			callerid_data *dat = *(it);
+
+			// Find me on their callerid list
+			if (!dat->accepting.erase(who))
+				ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "ERROR: Inconsistency detected in callerid state, please report (5)");
 		}
-		Implementation eventlist[] = { I_OnRehash, I_OnUserPreNick, I_OnUserQuit, I_On005Numeric, I_OnUserPreNotice, I_OnUserPreMessage, I_OnCleanup };
-		ServerInstance->Modules->Attach(eventlist, this, 7);
+
+		userdata->wholistsme.clear();
 	}
 
-	~ModuleCallerID()
+public:
+	ModuleCallerID()
+		: CTCTags::EventListener(this)
+		, cmd(this)
+		, api(this, cmd.extInfo)
+		, myumode(this, "callerid", 'g')
 	{
-		delete myumode;
 	}
 
-	Version GetVersion()
+	Version GetVersion() CXX11_OVERRIDE
 	{
-		return Version(1, 0, 0, 0, VF_COMMON | VF_VENDOR, API_VERSION);
+		return Version("Provides user mode g (bot) which allows users to require that other users are on their whitelist before messaging them.", VF_COMMON | VF_VENDOR);
 	}
 
-	void On005Numeric(std::string& output)
+	void On005Numeric(std::map<std::string, std::string>& tokens) CXX11_OVERRIDE
 	{
-		output += " CALLERID=g";
+		tokens["ACCEPT"] = ConvToStr(cmd.maxaccepts);
+		tokens["CALLERID"] = ConvToStr(myumode.GetModeChar());
 	}
 
-	int PreText(User* user, User* dest, std::string& text, bool notice)
+	ModResult HandleMessage(User* user, const MessageTarget& target)
 	{
-		if (!dest->IsModeSet('g')) return 0;
-		if (operoverride && IS_OPER(user)) return 0;
-		callerid_data* dat = GetData(dest, true);
-		std::set<User*>& accepting = dat->accepting;
-		time_t& lastnotify = dat->lastnotify;
-		std::set<User*>::iterator i = accepting.find(dest);
-		if (i == accepting.end())
+		if (!IS_LOCAL(user) || target.type != MessageTarget::TYPE_USER)
+			return MOD_RES_PASSTHRU;
+
+		User* dest = target.Get<User>();
+		if (!dest->IsModeSet(myumode) || (user == dest))
+			return MOD_RES_PASSTHRU;
+
+		if (user->HasPrivPermission("users/ignore-callerid"))
+			return MOD_RES_PASSTHRU;
+
+		callerid_data* dat = cmd.extInfo.get(dest, true);
+		if (!dat->accepting.count(user))
 		{
-			time_t now = time(NULL);
+			time_t now = ServerInstance->Time();
 			/* +g and *not* accepted */
-			user->WriteServ("716 %s %s :is in +g mode (server-side ignore).", user->nick, dest->nick);
-			if (now > (lastnotify + (time_t)notify_cooldown))
+			user->WriteNumeric(ERR_TARGUMODEG, dest->nick, "is in +g mode (server-side ignore).");
+			if (now > (dat->lastnotify + (time_t)notify_cooldown))
 			{
-				user->WriteServ("717 %s %s :has been informed that you messaged them.", user->nick, dest->nick);
-				dest->WriteServ("718 %s %s %s@%s :is messaging you, and you have umode +g", dest->nick, user->nick, user->ident, user->dhost);
-				lastnotify = now;
+				user->WriteNumeric(RPL_TARGNOTIFY, dest->nick, "has been informed that you messaged them.");
+				dest->WriteRemoteNumeric(RPL_UMODEGMSG, user->nick, InspIRCd::Format("%s@%s", user->ident.c_str(), user->GetDisplayedHost().c_str()), InspIRCd::Format("is messaging you, and you have user mode +g set. Use /ACCEPT +%s to allow.",
+						user->nick.c_str()));
+				dat->lastnotify = now;
 			}
-			return 1;
+			return MOD_RES_DENY;
 		}
-		return 0;
+		return MOD_RES_PASSTHRU;
 	}
 
-	int OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList &exempt_list)
+	ModResult OnUserPreMessage(User* user, const MessageTarget& target, MessageDetails& details) CXX11_OVERRIDE
 	{
-		if (IS_LOCAL(user) && target_type == TYPE_USER)
-			return PreText(user, (User*)dest, text, true);
-		return 0;
+		return HandleMessage(user, target);
 	}
 
-	int OnUserPreNotice(User* user, void* dest, int target_type, std::string& text, char status, CUList &exempt_list)
+	ModResult OnUserPreTagMessage(User* user, const MessageTarget& target, CTCTags::TagMessageDetails& details) CXX11_OVERRIDE
 	{
-		if (IS_LOCAL(user) && target_type == TYPE_USER)
-			return PreText(user, (User*)dest, text, true);
-		return 0;
+		return HandleMessage(user, target);
 	}
 
-	void OnCleanup(int type, void* item)
+	void OnUserPostNick(User* user, const std::string& oldnick) CXX11_OVERRIDE
 	{
-		if (type != TYPE_USER) return;
-		User* u = (User*)item;
-		/* Cleanup only happens on unload (before dtor), so keep this O(n) instead of O(n^2) which deferring to OnUserQuit would do.  */
-		RemoveData(u);
+		if (!tracknick)
+			RemoveFromAllAccepts(user);
 	}
 
-	int OnUserPreNick(User* user, const std::string& newnick)
+	void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) CXX11_OVERRIDE
 	{
-		if (!tracknick)
-			RemoveFromAllAccepts(ServerInstance, user);
-		return 0;
+		RemoveFromAllAccepts(user);
 	}
 
-	void OnUserQuit(User* user, const std::string& message, const std::string& oper_message)
+	void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
 	{
-		RemoveData(user);
-		RemoveFromAllAccepts(ServerInstance, user);
+		ConfigTag* tag = ServerInstance->Config->ConfValue("callerid");
+		cmd.maxaccepts = tag->getUInt("maxaccepts", 30);
+		tracknick = tag->getBool("tracknick");
+		notify_cooldown = tag->getDuration("cooldown", 60);
 	}
 
-	void OnRehash(User* user, const std::string& parameter)
+	void Prioritize() CXX11_OVERRIDE
 	{
-		ConfigReader Conf(ServerInstance);
-		int new_maxaccepts, new_cooldown;
-		bool new_override, new_track;
-		new_maxaccepts = Conf.ReadInteger("callerid", "maxaccepts", "16", 0, true);
-		switch (Conf.GetError())
-		{
-			case 0: break;
-			case CONF_VALUE_NOT_FOUND:
-				new_maxaccepts = 16;
-				break;
-			case CONF_NOT_A_NUMBER:
-				if (user) user->WriteServ("NOTICE %s :Invalid maxaccepts value '%s', not a number", Conf.ReadValue("callerid", "maxaccepts", "", 0).c_str());
-				throw ModuleException("Invalid maxaccepts value, not a number");
-			case CONF_INT_NEGATIVE:
-				if (user) user->WriteServ("NOTICE %s :Invalid maxaccepts value '%s', negative", Conf.ReadValue("callerid", "maxaccepts", "", 0).c_str());
-				throw ModuleException("Invalid maxaccepts value, negative");
-			default:
-				/* Yikes */
-				throw ModuleException("Invalid maxaccepts value, unknown config error");
-		}
-		new_override = Conf.ReadFlag("callerid", "operoverride", "0", 0);
-		if (Conf.GetError() == CONF_VALUE_NOT_FOUND) new_override = false;
-		new_track = Conf.ReadFlag("callerid", "tracknick", "0", 0);
-		if (Conf.GetError() == CONF_VALUE_NOT_FOUND) new_track = false;
-		new_cooldown = Conf.ReadInteger("callerid", "cooldown", "60", 0, true);
-		switch (Conf.GetError())
-		{
-			case 0: break;
-			case CONF_VALUE_NOT_FOUND:
-				new_cooldown = 16;
-				break;
-			case CONF_NOT_A_NUMBER:
-				if (user) user->WriteServ("NOTICE %s :Invalid cooldown value '%s', not a number", Conf.ReadValue("callerid", "maxaccepts", "", 0).c_str());
-				throw ModuleException("Invalid cooldown value, not a number");
-			case CONF_INT_NEGATIVE:
-				if (user) user->WriteServ("NOTICE %s :Invalid cooldown value '%s', negative", Conf.ReadValue("callerid", "maxaccepts", "", 0).c_str());
-				throw ModuleException("Invalid cooldown value, negative");
-			default:
-				/* Yikes */
-				throw ModuleException("Invalid cooldown value, unknown config error");
-		}
-		maxaccepts = new_maxaccepts;
-		notify_cooldown = new_cooldown;
-		operoverride = new_override;
-		tracknick = new_track;
+		// Want to be after modules like silence or services_account
+		ServerInstance->Modules->SetPriority(this, I_OnUserPreMessage, PRIORITY_LAST);
 	}
 };
 
 MODULE_INIT(ModuleCallerID)
-
-