char* Event::GetData()
{
- return (char*)this->data;
+ return this->data;
}
Module* Event::GetSource()
void Module::OnUserConnect(User*) { }
void Module::OnUserQuit(User*, const std::string&, const std::string&) { }
void Module::OnUserDisconnect(User*) { }
-void Module::OnUserJoin(User*, Channel*, bool, bool&) { }
+void Module::OnUserJoin(User*, Channel*, bool, bool&, bool) { }
void Module::OnPostJoin(User*, Channel*) { }
void Module::OnUserPart(User*, Channel*, std::string&, bool&) { }
void Module::OnPreRehash(User*, const std::string&) { }
void Module::OnModuleRehash(User*, const std::string&) { }
void Module::OnRehash(User*) { }
int Module::OnUserPreJoin(User*, Channel*, const char*, std::string&, const std::string&) { return 0; }
-void Module::OnMode(User*, void*, int, const std::deque<std::string>&, const std::deque<TranslateType>&) { }
+void Module::OnMode(User*, void*, int, const std::vector<std::string>&, const std::vector<TranslateType>&) { }
Version Module::GetVersion() { return Version("Misconfigured", VF_VENDOR, -1); }
void Module::OnOper(User*, const std::string&) { }
void Module::OnPostOper(User*, const std::string&, const std::string &) { }
void Module::OnPostConnect(User*) { }
int Module::OnAddBan(User*, Channel*, const std::string &) { return 0; }
int Module::OnDelBan(User*, Channel*, const std::string &) { return 0; }
-void Module::OnRawSocketAccept(int, const std::string&, int) { }
+void Module::OnRawSocketAccept(int, irc::sockets::sockaddrs*, irc::sockets::sockaddrs*) { }
int Module::OnRawSocketWrite(int, const char*, int) { return 0; }
void Module::OnRawSocketClose(int) { }
void Module::OnRawSocketConnect(int) { }
void Module::OnGetServerDescription(const std::string&, std::string&) { }
void Module::OnSyncUser(User*, Module*, void*) { }
void Module::OnSyncChannel(Channel*, Module*, void*) { }
-void Module::ProtoSendMode(void*, TargetTypeFlags, void*, const std::deque<std::string>&, const std::deque<TranslateType>&) { }
-void Module::OnSyncChannelMetaData(Channel*, Module*, void*, const std::string&, bool) { }
-void Module::OnSyncUserMetaData(User*, Module*, void*, const std::string&, bool) { }
-void Module::OnSyncOtherMetaData(Module*, void*, bool) { }
-void Module::OnDecodeMetaData(int, void*, const std::string&, const std::string&) { }
-void Module::ProtoSendMetaData(void*, TargetTypeFlags, void*, const std::string&, const std::string&) { }
+void Module::OnSyncNetwork(Module*, void*) { }
+void Module::ProtoSendMode(void*, TargetTypeFlags, void*, const std::vector<std::string>&, const std::vector<TranslateType>&) { }
+void Module::OnDecodeMetaData(Extensible*, const std::string&, const std::string&) { }
+void Module::ProtoSendMetaData(void*, Extensible*, const std::string&, const std::string&) { }
+std::string Module::ProtoTranslate(Extensible*) { return "?"; }
void Module::OnWallops(User*, const std::string&) { }
void Module::OnChangeHost(User*, const std::string&) { }
void Module::OnChangeName(User*, const std::string&) { }
void Module::OnRunTestSuite() { }
void Module::OnNamesListItem(User*, User*, Channel*, std::string&, std::string&) { }
int Module::OnNumeric(User*, unsigned int, const std::string&) { return 0; }
-void Module::OnHookUserIO(User*, const std::string&) { }
+void Module::OnHookUserIO(User*) { }
bool Module::OnHostCycle(User* user) { return false; }
ModuleManager::ModuleManager(InspIRCd* Ins) : ModCount(0), Instance(Ins)
break;
/* Module wants to be first, sod everything else */
case PRIORITY_FIRST:
- swap_pos = 0;
+ if (prioritizationState != PRIO_STATE_FIRST)
+ swap = false;
+ else
+ swap_pos = 0;
break;
- /* Module is submissive and wants to be last... awww. */
+ /* Module wants to be last. */
case PRIORITY_LAST:
- if (EventHandlers[i].empty())
+ if (prioritizationState != PRIO_STATE_FIRST)
+ swap = false;
+ else if (EventHandlers[i].empty())
swap_pos = 0;
else
swap_pos = EventHandlers[i].size() - 1;
/* Do we need to swap? */
if (swap && (swap_pos != source))
{
+ // We are going to change positions; we'll need to run again to verify all requirements
+ if (prioritizationState == PRIO_STATE_LAST)
+ prioritizationState = PRIO_STATE_AGAIN;
/* Suggestion from Phoenix, "shuffle" the modules to better retain call order */
int incrmnt = 1;
if (strchr(filename,'*') || (strchr(filename,'?')))
{
int n_match = 0;
- DIR* library = opendir(Instance->Config->ModPath);
+ DIR* library = opendir(Instance->Config->ModPath.c_str());
if (library)
{
/* Try and locate and load all modules matching the pattern */
}
char modfile[MAXBUF];
- snprintf(modfile,MAXBUF,"%s/%s",Instance->Config->ModPath,filename);
+ snprintf(modfile,MAXBUF,"%s/%s",Instance->Config->ModPath.c_str(),filename);
std::string filename_str = filename;
if (!ServerConfig::FileExists(modfile))
* not just the one thats loading, as the new module could affect the preference
* of others
*/
- for (std::map<std::string, std::pair<ircd_module*, Module*> >::iterator n = Modules.begin(); n != Modules.end(); ++n)
- n->second.second->Prioritize();
+ for(int tries = 0; tries < 20; tries++)
+ {
+ prioritizationState = tries > 0 ? PRIO_STATE_LAST : PRIO_STATE_FIRST;
+ for (std::map<std::string, std::pair<ircd_module*, Module*> >::iterator n = Modules.begin(); n != Modules.end(); ++n)
+ n->second.second->Prioritize();
+
+ if (prioritizationState == PRIO_STATE_LAST)
+ break;
+ if (tries == 19)
+ Instance->Logs->Log("MODULE", DEFAULT, "Hook priority dependency loop detected while loading " + filename_str);
+ }
Instance->BuildISupport();
return true;