public:
ModeUserServerNoticeMask();
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
- void OnParameterMissing(User* user, User* dest, Channel* channel);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE;
+ void OnParameterMissing(User* user, User* dest, Channel* channel) CXX11_OVERRIDE;
/** Create a displayable mode string of the snomasks set on a given user
* @param user The user whose notice masks to format
inline const ExtensibleStore& GetExtList() const { return extensions; }
Extensible();
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
virtual ~Extensible();
void doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove);
*/
virtual void Close();
/** This ensures that close is called prior to destructor */
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
/** Get the IOHook of a module attached to this socket
* @param mod Module whose IOHook to return
/** When there is data waiting to be read on a socket, the OnDataReady()
* method is called.
*/
- virtual void OnDataReady() = 0;
+ virtual void OnDataReady() CXX11_OVERRIDE = 0;
/**
* When an outbound connection fails, and the attempt times out, you
* @param mclass The object type of this mode handler, one of ModeHandler::Class
*/
ModeHandler(Module* me, const std::string& name, char modeletter, ParamSpec params, ModeType type, Class mclass = MC_OTHER);
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
virtual ~ModeHandler();
/** Register this object in the ModeParser
/** Clean up prior to destruction
* If you override, you must call this AFTER your module's cleanup
*/
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
/** Default destructor.
* destroys a module class
/** Default destructor
*/
virtual ~User();
- virtual CullResult cull();
+ virtual CullResult cull() CXX11_OVERRIDE;
};
class CoreExport UserIOHandler : public StreamSocket
{
public:
LocalUser(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
UserIOHandler eh;
*/
void SetClass(const std::string &explicit_name = "");
- bool SetClientIP(const char* sip, bool recheck_eline = true);
+ bool SetClientIP(const char* sip, bool recheck_eline = true) CXX11_OVERRIDE;
- void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true);
+ void SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline = true) CXX11_OVERRIDE;
- void Write(const std::string& text);
- void Write(const char*, ...) CUSTOM_PRINTF(2, 3);
+ void Write(const std::string& text) CXX11_OVERRIDE;
+ void Write(const char*, ...) CXX11_OVERRIDE CUSTOM_PRINTF(2, 3);
/** Send a NOTICE message from the local server to the user.
* The message will be sent even if the user is connected to a remote server.
* @param command A command (should be all CAPS)
* @return True if this user can execute the command
*/
- bool HasPermission(const std::string &command);
+ bool HasPermission(const std::string &command) CXX11_OVERRIDE;
/** Returns true if a user has a given permission.
* This is used to check whether or not users may perform certain actions which admins may not wish to give to
* @param noisy If set to true, the user is notified that they do not have the specified permission where applicable. If false, no notification is sent.
* @return True if this user has the permission in question.
*/
- bool HasPrivPermission(const std::string &privstr, bool noisy = false);
+ bool HasPrivPermission(const std::string &privstr, bool noisy = false) CXX11_OVERRIDE;
/** Returns true or false if a user can set a privileged user or channel mode.
* This is done by looking up their oper type from User::oper, then referencing
* @param mh Mode to check
* @return True if the user can set or unset this mode.
*/
- bool HasModePermission(const ModeHandler* mh) const;
+ bool HasModePermission(const ModeHandler* mh) const CXX11_OVERRIDE;
/** Change nick to uuid, unset REG_NICK and send a nickname overruled numeric.
* This is called when another user (either local or remote) needs the nick of this user and this user
nick = sname;
}
- virtual CullResult cull();
- virtual const std::string& GetFullHost();
- virtual const std::string& GetFullRealHost();
+ virtual CullResult cull() CXX11_OVERRIDE;
+ virtual const std::string& GetFullHost() CXX11_OVERRIDE;
+ virtual const std::string& GetFullRealHost() CXX11_OVERRIDE;
};
/* Faster than dynamic_cast */
}
}
- void Process(DNS::Request* req)
+ void Process(DNS::Request* req) CXX11_OVERRIDE
{
if ((unloading) || (req->creator->dying))
throw Exception("Module is being unloaded");
ServerInstance->Timers.AddTimer(req);
}
- void RemoveRequest(DNS::Request* req)
+ void RemoveRequest(DNS::Request* req) CXX11_OVERRIDE
{
if (requests[req->id] == req)
requests[req->id] = NULL;
}
- std::string GetErrorStr(Error e)
+ std::string GetErrorStr(Error e) CXX11_OVERRIDE
{
switch (e)
{
delete request;
}
- bool Tick(time_t now)
+ bool Tick(time_t now) CXX11_OVERRIDE
{
ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "cache: purging DNS cache");
this->manager.Rehash(DNSServer, SourceIP, SourcePort);
}
- void OnUnloadModule(Module* mod)
+ void OnUnloadModule(Module* mod) CXX11_OVERRIDE
{
for (unsigned int i = 0; i <= MAX_REQUEST_ID; ++i)
{
}
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("DNS support", VF_CORE|VF_VENDOR);
}
ph = &ptrHosts;
}
- void OnUserInit(LocalUser *user)
+ void OnUserInit(LocalUser *user) CXX11_OVERRIDE
{
if (!DNS || !user->MyClass->resolvehostnames)
{
}
}
- ModResult OnCheckReady(LocalUser* user)
+ ModResult OnCheckReady(LocalUser* user) CXX11_OVERRIDE
{
return this->dnsLookup.get(user) ? MOD_RES_DENY : MOD_RES_PASSTHRU;
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides support for DNS lookups on connecting clients", VF_CORE|VF_VENDOR);
}
{
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides the LOADMODULE and UNLOADMODULE commands", VF_VENDOR|VF_CORE);
}
{
}
- void OnPostConnect(User* user)
+ void OnPostConnect(User* user) CXX11_OVERRIDE
{
counters.UpdateMaxUsers();
if (user->IsModeSet(invisiblemode))
counters.invisible++;
}
- void OnUserQuit(User* user, const std::string& message, const std::string& oper_message)
+ void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) CXX11_OVERRIDE
{
if (user->IsModeSet(invisiblemode))
counters.invisible--;
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("LUSERS", VF_VENDOR | VF_CORE);
}
{
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("PRIVMSG, NOTICE", VF_CORE|VF_VENDOR);
}
{
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides the stub commands CONNECT, LINKS, SERVER and SQUIT", VF_VENDOR|VF_CORE);
}
{
}
- void OnGarbageCollect()
+ void OnGarbageCollect() CXX11_OVERRIDE
{
// Remove all entries older than MaxKeep
cmd.manager.Maintain();
}
- void OnUserQuit(User* user, const std::string& message, const std::string& oper_message)
+ void OnUserQuit(User* user, const std::string& message, const std::string& oper_message) CXX11_OVERRIDE
{
cmd.manager.Add(user);
}
cmd.manager.UpdateConfig(NewGroupSize, NewMaxGroups, NewMaxKeep);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("WHOWAS", VF_VENDOR);
}
stdalgo::delete_all(cmds);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("All commands", VF_VENDOR|VF_CORE);
}
}
}
- CullResult cull()
+ CullResult cull() CXX11_OVERRIDE
{
this->SQLProvider::cull();
ServerInstance->Modules->DelService(*this);
}
}
- void submit(SQLQuery *req, const std::string& q)
+ void submit(SQLQuery *req, const std::string& q) CXX11_OVERRIDE
{
if (qinprog.q.empty())
{
}
}
- void submit(SQLQuery *req, const std::string& q, const ParamL& p)
+ void submit(SQLQuery *req, const std::string& q, const ParamL& p) CXX11_OVERRIDE
{
std::string res;
unsigned int param = 0;
submit(req, res);
}
- void submit(SQLQuery *req, const std::string& q, const ParamM& p)
+ void submit(SQLQuery *req, const std::string& q, const ParamM& p) CXX11_OVERRIDE
{
std::string res;
for(std::string::size_type i = 0; i < q.length(); i++)
class ModuleAbbreviation : public Module
{
public:
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_FIRST);
}
ServerInstance->Parser.CallHandler(command, pars, user);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
// Prioritise after spanningtree so that channel aliases show the alias before the effects.
Module* linkmod = ServerInstance->Modules->Find("m_spanningtree.so");
bcrypt.rounds = conf->getInt("rounds", 10, 1);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Implements bcrypt hashing", VF_VENDOR);
}
{
}
- void init()
+ void init() CXX11_OVERRIDE
{
// Only attached while we are working; don't react to events otherwise
ServerInstance->Modules->DetachAll(this);
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
/* Needs to be after m_banexception etc. */
ServerInstance->Modules->SetPriority(this, I_OnCheckBan, PRIORITY_LAST);
defdelay = tag->getInt("delay", 0, 0, 60);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnPostConnect, PRIORITY_LAST);
}
class ModuleModesOnConnect : public Module
{
public:
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
// for things like +x on connect, important, otherwise we have to resort to config order (bleh) -- w00t
ServerInstance->Modules->SetPriority(this, I_OnUserConnect, PRIORITY_FIRST);
}
}
- void OnGarbageCollect()
+ void OnGarbageCollect() CXX11_OVERRIDE
{
ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Clearing map.");
connects.clear();
ExemptTargetSet exemptednicks;
ModuleFilter();
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
ModResult OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list, MessageType msgtype) CXX11_OVERRIDE;
FilterResult* FilterMatch(User* user, const std::string &text, int flags);
bool DeleteFilter(const std::string &freeform);
</cross-domain-policy>";
}
- CullResult cull()
+ CullResult cull() CXX11_OVERRIDE
{
for (insp::intrusive_list<FlashPDSocket>::const_iterator i = sockets.begin(); i != sockets.end(); ++i)
{
WriteData("\r\n");
}
- void OnDataReady()
+ void OnDataReady() CXX11_OVERRIDE
{
if (InternalState == HTTP_SERVE_RECV_POSTDATA)
{
return MOD_RES_ALLOW;
}
- void OnUnloadModule(Module* mod)
+ void OnUnloadModule(Module* mod) CXX11_OVERRIDE
{
for (insp::intrusive_list<HttpServerSocket>::const_iterator i = sockets.begin(); i != sockets.end(); )
{
last_excepts.clear();
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnUserJoin, PRIORITY_LAST);
}
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
// we want to be after all modules that might deny the message (e.g. m_muteban, m_noctcp, m_blockcolor, etc.)
ServerInstance->Modules->SetPriority(this, I_OnUserPreMessage, PRIORITY_LAST);
return Version("Implements the ability to have server-side MLOCK enforcement.", VF_VENDOR);
}
- ModResult OnRawMode(User* source, Channel* channel, ModeHandler* mh, const std::string& parameter, bool adding)
+ ModResult OnRawMode(User* source, Channel* channel, ModeHandler* mh, const std::string& parameter, bool adding) CXX11_OVERRIDE
{
if (!channel)
return MOD_RES_PASSTHRU;
return Version("Provides the ability to manipulate modes via long names.",VF_VENDOR);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnPreMode, PRIORITY_FIRST);
}
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module *nflood = ServerInstance->Modules->Find("m_nickflood.so");
ServerInstance->Modules->SetPriority(this, I_OnUserPreNick, PRIORITY_BEFORE, nflood);
return MOD_RES_DENY;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
ServerInstance->Modules->SetPriority(this, I_OnUserPreJoin, PRIORITY_FIRST);
}
return MOD_RES_PASSTHRU;
}
- void OnPostJoin(Membership* memb)
+ void OnPostJoin(Membership* memb) CXX11_OVERRIDE
{
if ((!IS_LOCAL(memb->user)) || (!memb->user->IsOper()) || (memb->user->IsModeSet(hideopermode)))
return;
return Version("Gives opers cmode +y which provides a staff prefix.", VF_VENDOR);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
// m_opermodes may set +H on the oper to hide him, we don't want to set the oper prefix in that case
Module* opermodes = ServerInstance->Modules->Find("m_opermodes.so");
dirty = false;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
// XXX: Load the DB here because the order in which modules are init()ed at boot is
// alphabetical, this means we must wait until all modules have done their init()
}
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module* mod = ServerInstance->Modules->Find("m_cgiirc.so");
ServerInstance->Modules->SetPriority(this, I_OnUserRegister, PRIORITY_AFTER, mod);
return MOD_RES_PASSTHRU;
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module *override = ServerInstance->Modules->Find("m_override.so");
ServerInstance->Modules->SetPriority(this, I_OnPreMode, PRIORITY_BEFORE, override);
big_endian = (htonl(1337) == 1337);
}
- Version GetVersion()
+ Version GetVersion() CXX11_OVERRIDE
{
return Version("Implements SHA-1 hashing", VF_VENDOR);
}
ServerInstance->XLines->UnregisterFactory(&f);
}
- void Prioritize()
+ void Prioritize() CXX11_OVERRIDE
{
Module* alias = ServerInstance->Modules->Find("m_alias.so");
ServerInstance->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_BEFORE, alias);
void OnUnloadModule(Module* mod) CXX11_OVERRIDE;
ModResult OnAcceptConnection(int newsock, ListenSocket* from, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server) CXX11_OVERRIDE;
void OnMode(User* source, User* u, Channel* c, const Modes::ChangeList& modes, ModeParser::ModeProcessFlag processflags, const std::string& output_mode) CXX11_OVERRIDE;
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
~ModuleSpanningTree();
Version GetVersion() CXX11_OVERRIDE;
- void Prioritize();
+ void Prioritize() CXX11_OVERRIDE;
};
void SendMetaData(Channel* chan, const std::string& key, const std::string& data) CXX11_OVERRIDE;
void SendMetaData(const std::string& key, const std::string& data) CXX11_OVERRIDE;
void SendSNONotice(char snomask, const std::string& text) CXX11_OVERRIDE;
- void SendMessage(Channel* target, char status, const std::string& text, MessageType msgtype);
- void SendMessage(User* target, const std::string& text, MessageType msgtype);
- void GetServerList(ServerList& sl);
+ void SendMessage(Channel* target, char status, const std::string& text, MessageType msgtype) CXX11_OVERRIDE;
+ void SendMessage(User* target, const std::string& text, MessageType msgtype) CXX11_OVERRIDE;
+ void GetServerList(ServerList& sl) CXX11_OVERRIDE;
};
void RegisterService() CXX11_OVERRIDE;
virtual CmdResult Handle(User* user, std::vector<std::string>& parameters) = 0;
- virtual RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ virtual RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
/**
* Extract the TS from a string.
*/
void OnPong() { pingtimer.OnPong(); }
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
/** Destructor, deletes ServerUser unless IsRoot()
*/
*/
void CleanNegotiationInfo();
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
/** Destructor
*/
~TreeSocket();
* to server docs on the inspircd.org site, the other side
* will then send back its own server string.
*/
- void OnConnected();
+ void OnConnected() CXX11_OVERRIDE;
/** Handle socket error event
*/
/** This function is called when we receive data from a remote
* server.
*/
- void OnDataReady();
+ void OnDataReady() CXX11_OVERRIDE;
/** Send one or more complete lines down the socket
*/
/** Handle socket timeout from connect()
*/
- void OnTimeout();
+ void OnTimeout() CXX11_OVERRIDE;
/** Handle server quit on close
*/
- void Close();
+ void Close() CXX11_OVERRIDE;
/** Fixes messages coming from old servers so the new command handlers understand them
*/
/** Prepare for class destruction
*/
- CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
/** Destroy class and free listeners etc
*/
}
}
- void OnChannelDelete(Channel* chan)
+ void OnChannelDelete(Channel* chan) CXX11_OVERRIDE
{
// Remove all timed bans affecting the channel from internal bookkeeping
TimedBanList.erase(std::remove_if(TimedBanList.begin(), TimedBanList.end(), ChannelMatcher(chan)), TimedBanList.end());