void Finish();
bool IsDone() { return done; }
};
+
+class CoreExport ConfigStatus
+{
+ public:
+ User* const srcuser;
+
+ ConfigStatus(User* user = NULL)
+ : srcuser(user)
+ {
+ }
+};
enum Implementation
{
I_BEGIN,
- I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart, I_OnRehash,
+ I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart,
I_OnSendSnotice, I_OnUserPreJoin, I_OnUserPreKick, I_OnUserKick, I_OnOper, I_OnInfo, I_OnWhois,
I_OnUserPreInvite, I_OnUserInvite, I_OnUserPreMessage, I_OnUserPreNick,
I_OnUserMessage, I_OnMode, I_OnGetServerDescription, I_OnSyncUser,
{
}
+ /** This method is called when you should reload module specific configuration:
+ * on boot, on a /REHASH and on module load.
+ * @param status The current status, can be inspected for more information;
+ * also used for reporting configuration errors and warnings.
+ */
+ virtual void ReadConfig(ConfigStatus& status);
+
/** Returns the version number of a Module.
* The method should return a Version object with its version information assigned via
* Version::Version
*/
virtual void OnModuleRehash(User* user, const std::string ¶meter);
- /** Called on rehash.
- * This method is called after a rehash has completed. You should use it to reload any module
- * configuration from the main configuration file.
- * @param user The user that performed the rehash, if it was initiated by a user and that user
- * is still connected.
- */
- virtual void OnRehash(User* user);
-
/** Called whenever a snotice is about to be sent to a snomask.
* snomask and type may both be modified; the message may not.
* @param snomask The snomask the message is going to (e.g. 'A')
/** Internal unload module hook */
bool CanUnload(Module*);
+
public:
+ typedef std::map<std::string, Module*> ModuleMap;
/** Event handler hooks.
* This needs to be public to be used by FOREACH_MOD and friends.
* @return The list of module names
*/
const std::vector<std::string> GetAllModuleNames(int filter);
+
+ /** Get a map of all loaded modules keyed by their name
+ * @return A ModuleMap containing all loaded modules
+ */
+ const ModuleMap& GetModules() const { return Modules; }
};
/** Do not mess with these functions unless you know the C preprocessor
class BufferedSocket;
class Channel;
class Command;
+class ConfigStatus;
class ConfigTag;
class Extensible;
class FakeUser;
void init()
{
ServerInstance->Modules->AddService(this->manager);
-
- this->OnRehash(NULL);
}
- void OnRehash(User* user)
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
std::string oldserver = DNSServer;
DNSServer = ServerInstance->Config->ConfValue("dns")->getString("server");
void init()
{
ServerInstance->Modules->AddService(cmd);
- OnRehash(NULL);
}
void OnGarbageCollect()
return MOD_RES_PASSTHRU;
}
- void OnRehash(User* user)
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("whowas");
unsigned int NewGroupSize = tag->getInt("groupsize", 10, 0, 10000);
static_cast<ListModeBase*>(*ban)->DoRehash();
Config->ApplyDisabledCommands(Config->DisabledCommands);
User* user = ServerInstance->FindNick(TheUserUID);
- FOREACH_MOD(OnRehash, (user));
+
+ ConfigStatus status(user);
+ const ModuleManager::ModuleMap& mods = ServerInstance->Modules->GetModules();
+ for (ModuleManager::ModuleMap::const_iterator i = mods.begin(); i != mods.end(); ++i)
+ i->second->ReadConfig(status);
+
ServerInstance->ISupport.Build();
ServerInstance->Logs->CloseLogs();
void ListModeBase::DoImplements(Module* m)
{
ServerInstance->Modules->AddService(extItem);
- this->DoRehash();
}
unsigned int ListModeBase::FindLimit(const std::string& channame)
}
else
{
+ ConfigStatus confstatus;
+
AttachAll(newmod);
newmod->init();
+ newmod->ReadConfig(confstatus);
Version v = newmod->GetVersion();
ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "New module introduced: %s (Module version %s)%s",
}
}
+ ConfigStatus confstatus;
+
for(std::map<std::string, Module*>::iterator i = Modules.begin(); i != Modules.end(); i++)
{
Module* mod = i->second;
ServerInstance->Logs->Log("MODULE", LOG_DEBUG, "Initializing %s", i->first.c_str());
AttachAll(mod);
mod->init();
+ mod->ReadConfig(confstatus);
}
catch (CoreException& modexcept)
{
}
else
{
+ ConfigStatus confstatus;
+
AttachAll(mod);
mod->init();
+ mod->ReadConfig(confstatus);
}
}
catch (CoreException& modexcept)
}
}
+ ConfigStatus confstatus;
+
for(std::map<std::string, Module*>::iterator i = Modules.begin(); i != Modules.end(); i++)
{
Module* mod = i->second;
{
AttachAll(mod);
mod->init();
+ mod->ReadConfig(confstatus);
}
catch (CoreException& modexcept)
{
ServerInstance->Modules->Detach(i, this);
}
+void Module::ReadConfig(ConfigStatus& status) { }
ModResult Module::OnSendSnotice(char &snomask, std::string &type, const std::string &message) { DetachEvent(I_OnSendSnotice); return MOD_RES_PASSTHRU; }
void Module::OnUserConnect(LocalUser*) { DetachEvent(I_OnUserConnect); }
void Module::OnUserQuit(User*, const std::string&, const std::string&) { DetachEvent(I_OnUserQuit); }
void Module::OnUserPart(Membership*, std::string&, CUList&) { DetachEvent(I_OnUserPart); }
void Module::OnPreRehash(User*, const std::string&) { DetachEvent(I_OnPreRehash); }
void Module::OnModuleRehash(User*, const std::string&) { DetachEvent(I_OnModuleRehash); }
-void Module::OnRehash(User*) { DetachEvent(I_OnRehash); }
ModResult Module::OnUserPreJoin(LocalUser*, Channel*, const std::string&, std::string&, const std::string&) { DetachEvent(I_OnUserPreJoin); return MOD_RES_PASSTHRU; }
void Module::OnMode(User*, User*, Channel*, const std::vector<std::string>&, const std::vector<TranslateType>&) { DetachEvent(I_OnMode); }
void Module::OnOper(User*, const std::string&) { DetachEvent(I_OnOper); }
{
ServerInstance->Modules->AddService(ldapAuthed);
ServerInstance->Modules->AddService(ldapVhost);
- OnRehash(NULL);
}
~ModuleLDAPAuth()
ldap_unbind_ext(conn, NULL, NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("ldapauth");
whitelistedcidrs.clear();
{
}
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
~ModuleLDAPAuth()
{
if (conn)
ldap_unbind_ext(conn, NULL, NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("ldapoper");
connections.clear();
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
queryDispatcher->LockQueue();
ReadConf();
ModuleSQL();
void init() CXX11_OVERRIDE;
~ModuleSQL();
- void OnRehash(User* user) CXX11_OVERRIDE;
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE;
void OnUnloadModule(Module* mod) CXX11_OVERRIDE;
Version GetVersion() CXX11_OVERRIDE;
};
{
Dispatcher = new DispatcherThread(this);
ServerInstance->Threads->Start(Dispatcher);
-
- OnRehash(NULL);
}
ModuleSQL::~ModuleSQL()
}
}
-void ModuleSQL::OnRehash(User* user)
+void ModuleSQL::ReadConfig(ConfigStatus& status)
{
ConnMap conns;
ConfigTagList tags = ServerInstance->Config->ConfTags("database");
{
}
- void init() CXX11_OVERRIDE
- {
- ReadConf();
- }
-
~ModulePgSQL()
{
delete retimer;
ClearAllConnections();
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ReadConf();
}
ModuleRegexPOSIX() : ref(this)
{
ServerInstance->Modules->AddService(ref);
- OnRehash(NULL);
}
Version GetVersion() CXX11_OVERRIDE
return Version("Regex Provider Module for POSIX Regular Expressions", VF_VENDOR);
}
- void OnRehash(User* u) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ref.extended = ServerInstance->Config->ConfValue("posix")->getBool("extended");
}
ModuleRegexStd() : ref(this)
{
ServerInstance->Modules->AddService(ref);
- OnRehash(NULL);
}
Version GetVersion() CXX11_OVERRIDE
return Version("Regex Provider Module for std::regex", VF_VENDOR);
}
- void OnRehash(User* u) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* Conf = ServerInstance->Config->ConfValue("stdregex");
std::string regextype = Conf->getString("type", "ecmascript");
ConnMap conns;
public:
- void init() CXX11_OVERRIDE
- {
- ReadConf();
- }
-
~ModuleSQLite3()
{
ClearConns();
conns.clear();
}
- void ReadConf()
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ClearConns();
ConfigTagList tags = ServerInstance->Config->ConfTags("database");
}
}
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- ReadConf();
- }
-
Version GetVersion() CXX11_OVERRIDE
{
return Version("sqlite3 provider", VF_VENDOR);
ServerInstance->Modules->AddService(starttls);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
sslports.clear();
std::string certfile;
std::string cafile;
std::string crlfile;
- OnRehash(user);
ConfigTag* Conf = ServerInstance->Config->ConfValue("gnutls");
}
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
sslports.clear();
std::string certfile;
std::string cafile;
std::string dhfile;
- OnRehash(user);
ConfigTag* conf = ServerInstance->Config->ConfValue("openssl");
bool AllowBots;
UserModeReference botmode;
- void ReadAliases()
+ public:
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* fantasy = ServerInstance->Config->ConfValue("fantasy");
AllowBots = fantasy->getBool("allowbots", false);
}
}
- public:
ModuleAlias()
: botmode(this, "bot")
{
}
- void init() CXX11_OVERRIDE
- {
- ReadAliases();
- }
-
Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides aliases of commands.", VF_VENDOR);
ServerInstance->Parser->CallHandler(command, pars, user);
}
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- ReadAliases();
- }
-
void Prioritize()
{
// Prioritise after spanningtree so that channel aliases show the alias before the effects.
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(aum);
-
- OnRehash(NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("auditorium");
OpsVisible = tag->getBool("opvisible");
mh.DoSyncChannel(chan, proto, opaque);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
mh.DoRehash();
}
be.DoSyncChannel(chan, proto, opaque);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
be.DoRehash();
}
void init() CXX11_OVERRIDE
{
- this->OnRehash(NULL);
ServerInstance->Modules->AddService(blockamsg);
}
return Version("Attempt to block /amsg, at least some of the irritating mIRC scripts.",VF_VENDOR);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("blockamsg");
ForgetDelay = tag->getInt("delay", -1);
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
ServerInstance->Modules->AddService(bc);
}
tokens["EXTBAN"].push_back('B');
}
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- ReadConf();
- }
-
ModResult OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list, MessageType msgtype) CXX11_OVERRIDE
{
if (target_type == TYPE_CHANNEL)
return MOD_RES_PASSTHRU;
}
- void ReadConf()
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("blockcaps");
percent = tag->getInt("percent", 100, 1, 100);
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
-
ServerInstance->Modules->AddService(myumode);
ServerInstance->Modules->AddService(cmd);
ServerInstance->Modules->AddService(cmd.extInfo);
RemoveFromAllAccepts(user);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("callerid");
cmd.maxaccepts = tag->getInt("maxaccepts", 16);
void init() CXX11_OVERRIDE
{
- /* Read the configuration file on startup.
- */
- OnRehash(NULL);
ServerInstance->Modules->AddService(cu);
ServerInstance->Modules->AddService(cc);
}
return MOD_RES_PASSTHRU;
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
/*
* reload our config file on rehash - we must destroy and re-allocate the classes
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
ServiceProvider* providerlist[] = { &cmd, &cmd.realhost, &cmd.realip, &cmd.webirc_hostname, &cmd.webirc_ip, &waiting };
ServerInstance->Modules->AddServices(providerlist, sizeof(providerlist)/sizeof(ServiceProvider*));
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
cmd.Hosts.clear();
ServerInstance->Modules->AddService(cf);
cf.DoImplements(this);
-
- OnRehash(NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
hidemask = ServerInstance->Config->ConfValue("chanfilter")->getBool("hidemask");
cf.DoRehash();
{
ServerInstance->Modules->AddService(m);
ServerInstance->Modules->AddService(m.ext);
-
- OnRehash(NULL);
}
- void OnRehash(User*) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("chanhistory");
m.maxlines = tag->getInt("maxlines", 50);
ChanLogTargets logstreams;
public:
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
- void OnRehash(User *user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
std::string snomasks;
std::string channel;
void init() CXX11_OVERRIDE
{
ServerInstance->IsChannel = &myhandler;
- OnRehash(NULL);
}
void ValidateChans()
badchan = false;
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("channames");
std::string denyToken = tag->getString("denyrange");
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
ServerInstance->Modules->AddService(cmd);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
std::string hmap = ServerInstance->Config->ConfValue("hostname")->getString("charmap", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-_/0123456789");
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
-
ServerInstance->Modules->AddService(cu);
ServerInstance->Modules->AddService(ck);
ServerInstance->Modules->AddService(cu.ext);
return Version("Provides masking of user hostnames", VF_COMMON|VF_VENDOR, testcloak);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("cloak");
prefix = tag->getString("prefix");
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(ext);
- OnRehash(NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("waitpong");
sendsnotice = tag->getBool("sendsnotice", true);
unsigned int ipv6_cidr;
public:
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
Version GetVersion() CXX11_OVERRIDE
{
return Version("Throttles the connections of IP ranges who try to connect flood.", VF_VENDOR);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("connectban");
{
}
- void init() CXX11_OVERRIDE
- {
- InitConf();
- }
-
Version GetVersion() CXX11_OVERRIDE
{
return Version("Connection throttle", VF_VENDOR);
}
- void InitConf()
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
/* read configuration variables */
ConfigTag* tag = ServerInstance->Config->ConfValue("connflood");
}
return MOD_RES_PASSTHRU;
}
-
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- InitConf();
- }
-
};
MODULE_INIT(ModuleConnFlood)
ext = new SimpleExtItem<dccallowlist>("dccallow", this);
ServerInstance->Modules->AddService(*ext);
ServerInstance->Modules->AddService(cmd);
- ReadFileConf();
- }
-
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- ReadFileConf();
}
void OnUserQuit(User* user, const std::string &reason, const std::string &oper_message) CXX11_OVERRIDE
}
}
- void ReadFileConf()
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
bfl.clear();
ConfigTagList tags = ServerInstance->Config->ConfTags("banfile");
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(m1);
-
- OnRehash(NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("deaf");
deaf_bypasschars = tag->getString("bypasschars");
{
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
/* check for redirect validity and loops/chains */
ConfigTagList tags = ServerInstance->Config->ConfTags("badchan");
if (!ServerInstance->IsChannel(redirect))
{
- if (user)
- user->WriteNotice("Invalid badchan redirect '" + redirect + "'");
+ if (status.srcuser)
+ status.srcuser->WriteNotice("Invalid badchan redirect '" + redirect + "'");
throw ModuleException("Invalid badchan redirect, not a channel");
}
if (!goodchan)
{
/* <badchan:redirect> is a badchan */
- if (user)
- user->WriteNotice("Badchan " + name + " redirects to badchan " + redirect);
+ if (status.srcuser)
+ status.srcuser->WriteNotice("Badchan " + name + " redirects to badchan " + redirect);
throw ModuleException("Badchan redirect loop");
}
}
void init() CXX11_OVERRIDE
{
- ReadConf();
ServerInstance->Modules->AddService(nameExt);
ServerInstance->Modules->AddService(countExt);
}
/** Fill our conf vector with data
*/
- void ReadConf()
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
DNSBLConfEntries.clear();
}
}
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- ReadConf();
- }
-
void OnSetUserIP(LocalUser* user) CXX11_OVERRIDE
{
if ((user->exempt) || (user->client_sa.sa.sa_family != AF_INET) || !DNS)
{
ServerInstance->Modules->AddService(eh.ec);
ServerInstance->OnCheckExemption = &eh;
-
- OnRehash(NULL);
}
~ModuleExemptChanOps()
return Version("Provides the ability to allow channel operators to be exempt from certain modes.",VF_VENDOR);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
eh.ec.DoRehash();
}
FilterResult* FilterMatch(User* user, const std::string &text, int flags);
bool DeleteFilter(const std::string &freeform);
std::pair<bool, std::string> AddFilter(const std::string &freeform, FilterAction type, const std::string &reason, long duration, const std::string &flags);
- void OnRehash(User* user) CXX11_OVERRIDE;
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE;
Version GetVersion() CXX11_OVERRIDE;
std::string EncodeFilter(FilterResult* filter);
FilterResult DecodeFilter(const std::string &data);
void ModuleFilter::init()
{
ServerInstance->Modules->AddService(filtcommand);
- OnRehash(NULL);
}
CullResult ModuleFilter::cull()
return MOD_RES_PASSTHRU;
}
-void ModuleFilter::OnRehash(User* user)
+void ModuleFilter::ReadConfig(ConfigStatus& status)
{
ConfigTagList tags = ServerInstance->Config->ConfTags("exemptfromfilter");
exemptfromfilter.clear();
void init() CXX11_OVERRIDE
{
- ReadConfig();
ServerInstance->Modules->AddService(ho);
ServerInstance->Modules->AddService(cmd);
}
- void ReadConfig()
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
helpop_map.clear();
}
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- ReadConfig();
- }
-
void OnWhois(User* src, User* dst) CXX11_OVERRIDE
{
if (dst->IsModeSet(ho))
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(hm);
- OnRehash(NULL);
}
Version GetVersion() CXX11_OVERRIDE
return Version("Provides support for hiding channels with user mode +I", VF_VENDOR);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
AffectsOpers = ServerInstance->Config->ConfValue("hidechans")->getBool("affectsopers");
}
std::string MySeparator;
public:
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* host = ServerInstance->Config->ConfValue("host");
MySuffix = host->getString("suffix");
{
}
- void OnRehash(User* user)
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
acl_list.clear();
ConfigTagList acls = ServerInstance->Config->ConfTags("httpdacl");
}
}
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
void BlockAccess(HTTPRequest* http, int returnval, const std::string &extraheaderkey = "", const std::string &extraheaderval="")
{
ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "BlockAccess (%d)", returnval);
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(ext);
- OnRehash(NULL);
}
Version GetVersion() CXX11_OVERRIDE
return Version("Provides support for RFC1413 ident lookups", VF_VENDOR);
}
- void OnRehash(User *user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
RequestTimeout = ServerInstance->Config->ConfValue("ident")->getInt("timeout", 5);
if (!RequestTimeout)
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(ie);
-
- OnRehash(NULL);
ie.DoImplements(this);
}
ie.DoSyncChannel(chan, proto, opaque);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
invite_bypass_key = ServerInstance->Config->ConfValue("inviteexception")->getBool("bypasskey", true);
ie.DoRehash();
{
}
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* conf = ServerInstance->Config->ConfValue("ircv3");
accountnotify = conf->getBool("accountnotify", true);
return MOD_RES_PASSTHRU;
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
// Emergency way to unlock
- if (!user) js.redirect_new_users = false;
+ if (!status.srcuser)
+ js.redirect_new_users = false;
}
Version GetVersion() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(kn);
ServerInstance->Modules->AddService(cmd);
-
- OnRehash(NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
std::string knocknotify = ServerInstance->Config->ConfValue("knock")->getString("notify");
irc::string notify(knocknotify.c_str());
ServerInstance->Modules->AddService(unlockcommand);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
// Emergency way to unlock
- if (!user) locked = false;
+ if (!status.srcuser)
+ locked = false;
}
ModResult OnUserRegister(LocalUser* user) CXX11_OVERRIDE
{
std::string url;
public:
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
url = ServerInstance->Config->ConfValue("security")->getString("maphide");
}
national_case_insensitive_map = m_lower;
ServerInstance->IsNick = &myhandler;
-
- OnRehash(NULL);
}
void On005Numeric(std::map<std::string, std::string>& tokens) CXX11_OVERRIDE
tokens["CASEMAPPING"] = casemapping;
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("nationalchars");
charset = tag->getString("file");
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
ServerInstance->Modules->AddService(nn);
}
return MOD_RES_PASSTHRU;
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
override = ServerInstance->Config->ConfValue("nonicks")->getBool("operoverride", false);
}
void init() CXX11_OVERRIDE
{
- /* Load config stuff */
- OnRehash(NULL);
-
std::string npre = ServerInstance->Config->ConfValue("ojoin")->getString("prefix");
char NPrefix = npre.empty() ? 0 : npre[0];
if (NPrefix && ServerInstance->Modes->FindPrefix(NPrefix))
return MOD_RES_PASSTHRU;
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* Conf = ServerInstance->Config->ConfValue("ojoin");
mycommand.notice = Conf->getBool("notice", true);
}
public:
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
-
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("operjoin");
void init() CXX11_OVERRIDE
{
ServerInstance->SNO->EnableSnomask('r', "OPERLOG");
- OnRehash(NULL);
}
Version GetVersion() CXX11_OVERRIDE
return Version("A module which logs all oper commands to the ircd log at default loglevel.", VF_VENDOR);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
tosnomask = ServerInstance->Config->ConfValue("operlog")->getBool("tosnomask", false);
}
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(cmd);
- OnRehash(NULL);
}
Version GetVersion() CXX11_OVERRIDE
cmd.ShowOperMOTD(user);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
cmd.opermotd.clear();
ConfigTag* conf = ServerInstance->Config->ConfValue("opermotd");
void init() CXX11_OVERRIDE
{
- // read our config options (main config file)
- OnRehash(NULL);
ServerInstance->SNO->EnableSnomask('v', "OVERRIDE");
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
- // re-read our config options on a rehash
+ // re-read our config options
ConfigTag* tag = ServerInstance->Config->ConfValue("override");
NoisyOverride = tag->getBool("noisy");
RequireKey = tag->getBool("requirekey");
std::string nickrequired, forwardmsg, forwardcmd;
public:
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
Version GetVersion() CXX11_OVERRIDE
{
return Version("Sends server password to NickServ", VF_VENDOR);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("passforward");
nickrequired = tag->getString("nick", "NickServ");
void init() CXX11_OVERRIDE
{
- /* Read the config file first */
- OnRehash(NULL);
-
ServerInstance->Modules->AddService(cmd);
}
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(p);
-
- OnRehash(NULL);
}
CullResult cull()
return Module::cull();
}
- void OnRehash(User *user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("permchanneldb");
permchannelsconf = tag->getString("filename");
{
ServerInstance->Modules->AddService(cmd1);
ServerInstance->Modules->AddService(cmd2);
- OnRehash(NULL);
}
void On005Numeric(std::map<std::string, std::string>& tokens) CXX11_OVERRIDE
tokens["REMOVE"];
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
supportnokicks = ServerInstance->Config->ConfValue("remove")->getBool("supportnokicks");
}
ServerInstance->Modules->AddService(rm);
ServerInstance->Modules->AddService(rm.ChanSet);
ServerInstance->Modules->AddService(rm.MemberInfoExt);
- rm.ReadConfig();
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
rm.ReadConfig();
}
{
std::set<irc::string> allowchans;
- void ReadConfig()
+ public:
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
allowchans.clear();
ConfigTagList tags = ServerInstance->Config->ConfTags("allowchannel");
}
}
- public:
- void init() CXX11_OVERRIDE
- {
- ReadConfig();
- }
-
- void OnRehash(User* user) CXX11_OVERRIDE
- {
- ReadConfig();
- }
-
ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven) CXX11_OVERRIDE
{
irc::string x(cname.c_str());
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
-
ServerInstance->Modules->AddService(r);
ServerInstance->XLines->RegisterFactory(&f);
}
return MOD_RES_PASSTHRU;
}
- void OnRehash(User *user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("rline");
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
-
ServiceProvider* providelist[] = { &auth, &sasl, &authExt };
ServerInstance->Modules->AddServices(providelist, 3);
ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "WARNING: m_services_account.so and m_cap.so are not loaded! m_sasl.so will NOT function correctly until these two modules are loaded!");
}
- void OnRehash(User*) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
sasl_target = ServerInstance->Config->ConfValue("sasl")->getString("target", "*");
}
time_t WaitTime;
public:
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
Version GetVersion() CXX11_OVERRIDE
{
return Version("Disallows /LIST for recently connected clients to hinder spam bots", VF_VENDOR);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
allowlist.clear();
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
ServerInstance->Modules->AddService(cmd);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
std::string hmap = ServerInstance->Config->ConfValue("hostname")->getString("charmap", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-_/0123456789");
{
ServerInstance->XLines->RegisterFactory(&f);
ServerInstance->Modules->AddService(cmd);
-
- OnRehash(NULL);
}
~ModuleShun()
return MOD_RES_DENY;
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("shun");
std::string cmds = tag->getString("enabledcommands");
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
ServerInstance->Modules->AddService(cmdsilence);
ServerInstance->Modules->AddService(cmdsvssilence);
ServerInstance->Modules->AddService(cmdsilence.ext);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
maxsilence = ServerInstance->Config->ConfValue("showwhois")->getInt("maxentries", 32);
if (!maxsilence)
}
}
-void ModuleSpanningTree::OnRehash(User* user)
+void ModuleSpanningTree::ReadConfig(ConfigStatus& status)
{
// Re-read config stuff
try
std::string msg = "Error in configuration: ";
msg.append(e.GetReason());
ServerInstance->SNO->WriteToSnoMask('l', msg);
- if (user && !IS_LOCAL(user))
+ if (status.srcuser && !IS_LOCAL(status.srcuser))
ServerInstance->PI->SendSNONotice("L", msg);
}
}
void OnUserPostNick(User* user, const std::string &oldnick) CXX11_OVERRIDE;
void OnUserKick(User* source, Membership* memb, const std::string &reason, CUList& excepts) CXX11_OVERRIDE;
void OnPreRehash(User* user, const std::string ¶meter) CXX11_OVERRIDE;
- void OnRehash(User* user) CXX11_OVERRIDE;
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE;
void OnOper(User* user, const std::string &opertype) CXX11_OVERRIDE;
void OnLine(User* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason);
void OnAddLine(User *u, XLine *x) CXX11_OVERRIDE;
: Creator(C), TreeRoot(NULL)
{
ServerInstance->Timers->AddTimer(&RefreshTimer);
-
- this->ReadConfiguration();
}
CullResult SpanningTreeUtilities::cull()
void init() CXX11_OVERRIDE
{
ServerInstance->Modules->AddService(pendingExt);
- OnRehash(NULL);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* conf = ServerInstance->Config->ConfValue("sqlauth");
std::string dbid = conf->getString("dbid");
public:
ModuleSQLOper() : SQL(this, "SQL") {}
- void init() CXX11_OVERRIDE
- {
- OnRehash(NULL);
- }
-
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* tag = ServerInstance->Config->ConfValue("sqloper");
void init() CXX11_OVERRIDE
{
- OnRehash(NULL);
ServerInstance->Modules->AddService(cmdw);
ServerInstance->Modules->AddService(sw);
ServerInstance->Modules->AddService(cmdw.ext);
}
- void OnRehash(User* user) CXX11_OVERRIDE
+ void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
maxwatch = ServerInstance->Config->ConfValue("watch")->getInt("maxentries", 32);
if (!maxwatch)
{
/* Load the configuration
* Note:
- * this is on purpose not in the OnRehash() method. It would be non-trivial to change the database on-the-fly.
+ * This is on purpose not changed on a rehash. It would be non-trivial to change the database on-the-fly.
* Imagine a scenario where the new file already exists. Merging the current XLines with the existing database is likely a bad idea
* ...and so is discarding all current in-memory XLines for the ones in the database.
*/