X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules.cpp;h=7e602d9443fcca14d77243c4697d355ed68bda45;hb=8cb20e354533fbec24aafd4e61ff6fa69b434aa2;hp=2825b2d0ea3ea8105e92cc40b3be24bef655428d;hpb=82435b6fa8805baa65e04a582f3e4a2c84237f73;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules.cpp b/src/modules.cpp index 2825b2d0e..7e602d944 100644 --- a/src/modules.cpp +++ b/src/modules.cpp @@ -32,15 +32,13 @@ #include #endif -static intrusive_list* dynrefs = NULL; -static bool dynref_init_complete = false; +static insp::intrusive_list* dynrefs = NULL; void dynamic_reference_base::reset_all() { - dynref_init_complete = true; if (!dynrefs) return; - for (intrusive_list::iterator i = dynrefs->begin(); i != dynrefs->end(); ++i) + for (insp::intrusive_list::iterator i = dynrefs->begin(); i != dynrefs->end(); ++i) (*i)->resolve(); } @@ -54,13 +52,6 @@ Version::Version(const std::string &desc, int flags, const std::string& linkdata { } -Event::Event(Module* src, const std::string &eventid) : source(src), id(eventid) { } - -void Event::Send() -{ - FOREACH_MOD(OnEvent, (*this)); -} - // These declarations define the behavours of the base class Module (which does nothing at all) Module::Module() { } @@ -88,23 +79,23 @@ void Module::OnUserPart(Membership*, std::string&, CUList&) { DetachEvent(I_OnU void Module::OnPreRehash(User*, const std::string&) { DetachEvent(I_OnPreRehash); } void Module::OnModuleRehash(User*, const std::string&) { DetachEvent(I_OnModuleRehash); } 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&, const std::vector&) { DetachEvent(I_OnMode); } +void Module::OnMode(User*, User*, Channel*, const Modes::ChangeList&, ModeParser::ModeProcessFlag, const std::string&) { DetachEvent(I_OnMode); } void Module::OnOper(User*, const std::string&) { DetachEvent(I_OnOper); } void Module::OnPostOper(User*, const std::string&, const std::string &) { DetachEvent(I_OnPostOper); } +void Module::OnPostDeoper(User*) { DetachEvent(I_OnPostDeoper); } void Module::OnInfo(User*) { DetachEvent(I_OnInfo); } -void Module::OnWhois(User*, User*) { DetachEvent(I_OnWhois); } ModResult Module::OnUserPreInvite(User*, User*, Channel*, time_t) { DetachEvent(I_OnUserPreInvite); return MOD_RES_PASSTHRU; } -ModResult Module::OnUserPreMessage(User*, void*, int, std::string&, char, CUList&, MessageType) { DetachEvent(I_OnUserPreMessage); return MOD_RES_PASSTHRU; } -ModResult Module::OnUserPreNick(User*, const std::string&) { DetachEvent(I_OnUserPreNick); return MOD_RES_PASSTHRU; } +ModResult Module::OnUserPreMessage(User*, const MessageTarget&, MessageDetails&) { DetachEvent(I_OnUserPreMessage); return MOD_RES_PASSTHRU; } +ModResult Module::OnUserPreNick(LocalUser*, const std::string&) { DetachEvent(I_OnUserPreNick); return MOD_RES_PASSTHRU; } void Module::OnUserPostNick(User*, const std::string&) { DetachEvent(I_OnUserPostNick); } -ModResult Module::OnPreMode(User*, User*, Channel*, const std::vector&) { DetachEvent(I_OnPreMode); return MOD_RES_PASSTHRU; } +ModResult Module::OnPreMode(User*, User*, Channel*, Modes::ChangeList&) { DetachEvent(I_OnPreMode); return MOD_RES_PASSTHRU; } void Module::On005Numeric(std::map&) { DetachEvent(I_On005Numeric); } ModResult Module::OnKill(User*, User*, const std::string&) { DetachEvent(I_OnKill); return MOD_RES_PASSTHRU; } void Module::OnLoadModule(Module*) { DetachEvent(I_OnLoadModule); } void Module::OnUnloadModule(Module*) { DetachEvent(I_OnUnloadModule); } void Module::OnBackgroundTimer(time_t) { DetachEvent(I_OnBackgroundTimer); } -ModResult Module::OnPreCommand(std::string&, std::vector&, LocalUser*, bool, const std::string&) { DetachEvent(I_OnPreCommand); return MOD_RES_PASSTHRU; } -void Module::OnPostCommand(Command*, const std::vector&, LocalUser*, CmdResult, const std::string&) { DetachEvent(I_OnPostCommand); } +ModResult Module::OnPreCommand(std::string&, CommandBase::Params&, LocalUser*, bool, const std::string&) { DetachEvent(I_OnPreCommand); return MOD_RES_PASSTHRU; } +void Module::OnPostCommand(Command*, const CommandBase::Params&, LocalUser*, CmdResult, const std::string&) { DetachEvent(I_OnPostCommand); } void Module::OnUserInit(LocalUser*) { DetachEvent(I_OnUserInit); } ModResult Module::OnCheckReady(LocalUser*) { DetachEvent(I_OnCheckReady); return MOD_RES_PASSTHRU; } ModResult Module::OnUserRegister(LocalUser*) { DetachEvent(I_OnUserRegister); return MOD_RES_PASSTHRU; } @@ -117,20 +108,15 @@ ModResult Module::OnCheckLimit(User*, Channel*) { DetachEvent(I_OnCheckLimit); r ModResult Module::OnCheckChannelBan(User*, Channel*) { DetachEvent(I_OnCheckChannelBan); return MOD_RES_PASSTHRU; } ModResult Module::OnCheckBan(User*, Channel*, const std::string&) { DetachEvent(I_OnCheckBan); return MOD_RES_PASSTHRU; } ModResult Module::OnExtBanCheck(User*, Channel*, char) { DetachEvent(I_OnExtBanCheck); return MOD_RES_PASSTHRU; } -ModResult Module::OnStats(char, User*, string_list&) { DetachEvent(I_OnStats); return MOD_RES_PASSTHRU; } ModResult Module::OnChangeLocalUserHost(LocalUser*, const std::string&) { DetachEvent(I_OnChangeLocalUserHost); return MOD_RES_PASSTHRU; } -ModResult Module::OnChangeLocalUserGECOS(LocalUser*, const std::string&) { DetachEvent(I_OnChangeLocalUserGECOS); return MOD_RES_PASSTHRU; } +ModResult Module::OnPreChangeRealName(LocalUser*, const std::string&) { DetachEvent(I_OnPreChangeRealName); return MOD_RES_PASSTHRU; } ModResult Module::OnPreTopicChange(User*, Channel*, const std::string&) { DetachEvent(I_OnPreTopicChange); return MOD_RES_PASSTHRU; } -void Module::OnEvent(Event&) { DetachEvent(I_OnEvent); } ModResult Module::OnPassCompare(Extensible* ex, const std::string &password, const std::string &input, const std::string& hashtype) { DetachEvent(I_OnPassCompare); return MOD_RES_PASSTHRU; } -void Module::OnGlobalOper(User*) { DetachEvent(I_OnGlobalOper); } void Module::OnPostConnect(User*) { DetachEvent(I_OnPostConnect); } -void Module::OnUserMessage(User*, void*, int, const std::string&, char, const CUList&, MessageType) { DetachEvent(I_OnUserMessage); } -void Module::OnUserInvite(User*, User*, Channel*, time_t) { DetachEvent(I_OnUserInvite); } +void Module::OnUserPostMessage(User*, const MessageTarget&, const MessageDetails&) { DetachEvent(I_OnUserPostMessage); } +void Module::OnUserMessageBlocked(User*, const MessageTarget&, const MessageDetails&) { DetachEvent(I_OnUserMessageBlocked); } +void Module::OnUserInvite(User*, User*, Channel*, time_t, unsigned int, CUList&) { DetachEvent(I_OnUserInvite); } void Module::OnPostTopicChange(User*, Channel*, const std::string&) { DetachEvent(I_OnPostTopicChange); } -void Module::OnSyncUser(User*, ProtocolInterface::Server&) { DetachEvent(I_OnSyncUser); } -void Module::OnSyncChannel(Channel*, ProtocolInterface::Server&) { DetachEvent(I_OnSyncChannel); } -void Module::OnSyncNetwork(ProtocolInterface::Server&) { DetachEvent(I_OnSyncNetwork); } void Module::OnDecodeMetaData(Extensible*, const std::string&, const std::string&) { DetachEvent(I_OnDecodeMetaData); } void Module::OnChangeHost(User*, const std::string&) { DetachEvent(I_OnChangeHost); } void Module::OnChangeName(User*, const std::string&) { DetachEvent(I_OnChangeName); } @@ -138,20 +124,21 @@ void Module::OnChangeIdent(User*, const std::string&) { DetachEvent(I_OnChangeI void Module::OnAddLine(User*, XLine*) { DetachEvent(I_OnAddLine); } void Module::OnDelLine(User*, XLine*) { DetachEvent(I_OnDelLine); } void Module::OnExpireLine(XLine*) { DetachEvent(I_OnExpireLine); } -void Module::OnCleanup(int, void*) { } +void Module::OnCleanup(ExtensionItem::ExtensibleType, Extensible*) { } ModResult Module::OnChannelPreDelete(Channel*) { DetachEvent(I_OnChannelPreDelete); return MOD_RES_PASSTHRU; } void Module::OnChannelDelete(Channel*) { DetachEvent(I_OnChannelDelete); } ModResult Module::OnSetAway(User*, const std::string &) { DetachEvent(I_OnSetAway); return MOD_RES_PASSTHRU; } -ModResult Module::OnWhoisLine(User*, User*, int&, std::string&) { DetachEvent(I_OnWhoisLine); return MOD_RES_PASSTHRU; } void Module::OnBuildNeighborList(User*, IncludeChanList&, std::map&) { DetachEvent(I_OnBuildNeighborList); } void Module::OnGarbageCollect() { DetachEvent(I_OnGarbageCollect); } ModResult Module::OnSetConnectClass(LocalUser* user, ConnectClass* myclass) { DetachEvent(I_OnSetConnectClass); return MOD_RES_PASSTHRU; } -void Module::OnText(User*, void*, int, const std::string&, char, CUList&) { DetachEvent(I_OnText); } +void Module::OnUserMessage(User*, const MessageTarget&, const MessageDetails&) { DetachEvent(I_OnUserMessage); } ModResult Module::OnNamesListItem(User*, Membership*, std::string&, std::string&) { DetachEvent(I_OnNamesListItem); return MOD_RES_PASSTHRU; } -ModResult Module::OnNumeric(User*, unsigned int, const std::string&) { DetachEvent(I_OnNumeric); return MOD_RES_PASSTHRU; } +ModResult Module::OnNumeric(User*, const Numeric::Numeric&) { DetachEvent(I_OnNumeric); return MOD_RES_PASSTHRU; } ModResult Module::OnAcceptConnection(int, ListenSocket*, irc::sockets::sockaddrs*, irc::sockets::sockaddrs*) { DetachEvent(I_OnAcceptConnection); return MOD_RES_PASSTHRU; } -void Module::OnSendWhoLine(User*, const std::vector&, User*, Membership*, std::string&) { DetachEvent(I_OnSendWhoLine); } +ModResult Module::OnSendWhoLine(User*, const std::vector&, User*, Membership*, Numeric::Numeric&) { DetachEvent(I_OnSendWhoLine); return MOD_RES_PASSTHRU; } void Module::OnSetUserIP(LocalUser*) { DetachEvent(I_OnSetUserIP); } +void Module::OnServiceAdd(ServiceProvider&) { DetachEvent(I_OnServiceAdd); } +void Module::OnServiceDel(ServiceProvider&) { DetachEvent(I_OnServiceDel); } #ifdef INSPIRCD_ENABLE_TESTSUITE void Module::OnRunTestSuite() { } @@ -167,12 +154,7 @@ ServiceProvider::ServiceProvider(Module* Creator, const std::string& Name, Servi void ServiceProvider::DisableAutoRegister() { if ((ServerInstance) && (ServerInstance->Modules->NewServices)) - { - ModuleManager::ServiceList& list = *ServerInstance->Modules->NewServices; - ModuleManager::ServiceList::iterator it = std::find(list.begin(), list.end(), this); - if (it != list.end()) - list.erase(it); - } + stdalgo::erase(*ServerInstance->Modules->NewServices, this); } ModuleManager::ModuleManager() @@ -185,7 +167,7 @@ ModuleManager::~ModuleManager() bool ModuleManager::Attach(Implementation i, Module* mod) { - if (std::find(EventHandlers[i].begin(), EventHandlers[i].end(), mod) != EventHandlers[i].end()) + if (stdalgo::isin(EventHandlers[i], mod)) return false; EventHandlers[i].push_back(mod); @@ -194,13 +176,7 @@ bool ModuleManager::Attach(Implementation i, Module* mod) bool ModuleManager::Detach(Implementation i, Module* mod) { - EventHandlerIter x = std::find(EventHandlers[i].begin(), EventHandlers[i].end(), mod); - - if (x == EventHandlers[i].end()) - return false; - - EventHandlers[i].erase(x); - return true; + return stdalgo::erase(EventHandlers[i], mod); } void ModuleManager::Attach(Implementation* i, Module* mod, size_t sz) @@ -211,22 +187,20 @@ void ModuleManager::Attach(Implementation* i, Module* mod, size_t sz) void ModuleManager::AttachAll(Module* mod) { - for (size_t i = I_BEGIN + 1; i != I_END; ++i) + for (size_t i = 0; i != I_END; ++i) Attach((Implementation)i, mod); } void ModuleManager::DetachAll(Module* mod) { - for (size_t n = I_BEGIN + 1; n != I_END; ++n) + for (size_t n = 0; n != I_END; ++n) Detach((Implementation)n, mod); } -bool ModuleManager::SetPriority(Module* mod, Priority s) +void ModuleManager::SetPriority(Module* mod, Priority s) { - for (size_t n = I_BEGIN + 1; n != I_END; ++n) + for (size_t n = 0; n != I_END; ++n) SetPriority(mod, (Implementation)n, s); - - return true; } bool ModuleManager::SetPriority(Module* mod, Implementation i, Priority s, Module* which) @@ -363,17 +337,23 @@ bool ModuleManager::CanUnload(Module* mod) ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, LastModuleError); return false; } - if (mod->GetVersion().Flags & VF_STATIC) - { - LastModuleError = "Module " + mod->ModuleSourceFile + " not unloadable (marked static)"; - ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, LastModuleError); - return false; - } mod->dying = true; return true; } +void ModuleManager::UnregisterModes(Module* mod, ModeType modetype) +{ + const ModeParser::ModeHandlerMap& modes = ServerInstance->Modes.GetModes(modetype); + for (ModeParser::ModeHandlerMap::const_iterator i = modes.begin(); i != modes.end(); ) + { + ModeHandler* const mh = i->second; + ++i; + if (mh->creator == mod) + this->DelService(*mh); + } +} + void ModuleManager::DoSafeUnload(Module* mod) { // First, notify all modules that a module is about to be unloaded, so in case @@ -383,6 +363,10 @@ void ModuleManager::DoSafeUnload(Module* mod) std::map::iterator modfind = Modules.find(mod->ModuleSourceFile); + // Unregister modes before extensions because modes may require their extension to show the mode being unset + UnregisterModes(mod, MODETYPE_USER); + UnregisterModes(mod, MODETYPE_CHANNEL); + std::vector > items; ServerInstance->Extensions.BeginUnregister(modfind->second, items); /* Give the module a chance to tidy out all its metadata */ @@ -391,11 +375,14 @@ void ModuleManager::DoSafeUnload(Module* mod) { Channel* chan = c->second; ++c; - mod->OnCleanup(TYPE_CHANNEL, chan); + mod->OnCleanup(ExtensionItem::EXT_CHANNEL, chan); chan->doUnhookExtensions(items); - const UserMembList* users = chan->GetUsers(); - for(UserMembCIter mi = users->begin(); mi != users->end(); mi++) + const Channel::MemberMap& users = chan->GetUsers(); + for (Channel::MemberMap::const_iterator mi = users.begin(); mi != users.end(); ++mi) + { + mod->OnCleanup(ExtensionItem::EXT_MEMBERSHIP, mi->second); mi->second->doUnhookExtensions(items); + } } const user_hash& users = ServerInstance->Users->GetUsers(); @@ -404,28 +391,10 @@ void ModuleManager::DoSafeUnload(Module* mod) User* user = u->second; // The module may quit the user (e.g. SSL mod unloading) and that will remove it from the container ++u; - mod->OnCleanup(TYPE_USER, user); + mod->OnCleanup(ExtensionItem::EXT_USER, user); user->doUnhookExtensions(items); } - const ModeParser::ModeHandlerMap& usermodes = ServerInstance->Modes->GetModes(MODETYPE_USER); - for (ModeParser::ModeHandlerMap::const_iterator i = usermodes.begin(); i != usermodes.end(); ) - { - ModeHandler* mh = i->second; - ++i; - if (mh->creator == mod) - this->DelService(*mh); - } - - const ModeParser::ModeHandlerMap& chanmodes = ServerInstance->Modes->GetModes(MODETYPE_CHANNEL); - for (ModeParser::ModeHandlerMap::const_iterator i = chanmodes.begin(); i != chanmodes.end(); ) - { - ModeHandler* mh = i->second; - ++i; - if (mh->creator == mod) - this->DelService(*mh); - } - for(std::multimap::iterator i = DataProviders.begin(); i != DataProviders.end(); ) { std::multimap::iterator curr = i++; @@ -469,11 +438,11 @@ void ModuleManager::UnloadAll() namespace { - struct UnloadAction : public HandlerBase0 + struct UnloadAction : public ActionBase { Module* const mod; UnloadAction(Module* m) : mod(m) {} - void Call() + void Call() CXX11_OVERRIDE { DLLManager* dll = mod->ModuleDLLManager; ServerInstance->Modules->DoSafeUnload(mod); @@ -483,26 +452,6 @@ namespace ServerInstance->GlobalCulls.AddItem(this); } }; - - struct ReloadAction : public HandlerBase0 - { - Module* const mod; - HandlerBase1* const callback; - ReloadAction(Module* m, HandlerBase1* c) - : mod(m), callback(c) {} - void Call() - { - DLLManager* dll = mod->ModuleDLLManager; - std::string name = mod->ModuleSourceFile; - ServerInstance->Modules->DoSafeUnload(mod); - ServerInstance->GlobalCulls.Apply(); - delete dll; - bool rv = ServerInstance->Modules->Load(name); - if (callback) - callback->Call(rv); - ServerInstance->GlobalCulls.AddItem(this); - } - }; } bool ModuleManager::Unload(Module* mod) @@ -513,14 +462,6 @@ bool ModuleManager::Unload(Module* mod) return true; } -void ModuleManager::Reload(Module* mod, HandlerBase1* callback) -{ - if (CanUnload(mod)) - ServerInstance->AtomicActions.AddAction(new ReloadAction(mod, callback)); - else - callback->Call(false); -} - void ModuleManager::LoadAll() { std::map servicemap; @@ -530,10 +471,14 @@ void ModuleManager::LoadAll() for (ConfigIter i = tags.first; i != tags.second; ++i) { ConfigTag* tag = i->second; - std::string name = tag->getString("name"); + std::string name = ExpandModName(tag->getString("name")); this->NewServices = &servicemap[name]; - std::cout << "[" << con_green << "*" << con_reset << "] Loading module:\t" << con_green << name << con_reset << std::endl; + // Skip modules which are already loaded. + if (Modules.find(name) != Modules.end()) + continue; + + std::cout << "[" << con_green << "*" << con_reset << "] Loading module:\t" << con_green << name << con_reset << std::endl; if (!this->Load(name, true)) { ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, this->LastError()); @@ -588,22 +533,6 @@ void ModuleManager::AddService(ServiceProvider& item) { switch (item.service) { - case SERVICE_COMMAND: - if (!ServerInstance->Parser.AddCommand(static_cast(&item))) - throw ModuleException("Command "+std::string(item.name)+" already exists."); - return; - case SERVICE_MODE: - { - ModeHandler* mh = static_cast(&item); - ServerInstance->Modes->AddMode(mh); - DataProviders.insert(std::make_pair((mh->GetModeType() == MODETYPE_CHANNEL ? "mode/" : "umode/") + item.name, &item)); - dynamic_reference_base::reset_all(); - return; - } - case SERVICE_METADATA: - if (!ServerInstance->Extensions.Register(static_cast(&item))) - throw ModuleException("Extension " + std::string(item.name) + " already exists."); - return; case SERVICE_DATA: case SERVICE_IOHOOK: { @@ -618,11 +547,13 @@ void ModuleManager::AddService(ServiceProvider& item) DataProviders.insert(std::make_pair(item.name.substr(slash + 1), &item)); } dynamic_reference_base::reset_all(); - return; + break; } default: - throw ModuleException("Cannot add unknown service type"); + item.RegisterService(); } + + FOREACH_MOD(OnServiceAdd, (item)); } void ModuleManager::DelService(ServiceProvider& item) @@ -636,18 +567,14 @@ void ModuleManager::DelService(ServiceProvider& item) case SERVICE_DATA: case SERVICE_IOHOOK: { - for(std::multimap::iterator i = DataProviders.begin(); i != DataProviders.end(); ) - { - std::multimap::iterator curr = i++; - if (curr->second == &item) - DataProviders.erase(curr); - } - dynamic_reference_base::reset_all(); + DelReferent(&item); return; } default: throw ModuleException("Cannot delete unknown service type"); } + + FOREACH_MOD(OnServiceDel, (item)); } ServiceProvider* ModuleManager::FindService(ServiceType type, const std::string& name) @@ -668,13 +595,25 @@ ServiceProvider* ModuleManager::FindService(ServiceType type, const std::string& } } +std::string ModuleManager::ExpandModName(const std::string& modname) +{ + // Transform "callerid" -> "m_callerid.so" unless it already has a ".so" extension, + // so coremods in the "core_*.so" form aren't changed + std::string ret = modname; + if ((modname.length() < 3) || (modname.compare(modname.size() - 3, 3, ".so"))) + ret.insert(0, "m_").append(".so"); + return ret; +} + dynamic_reference_base::dynamic_reference_base(Module* Creator, const std::string& Name) - : name(Name), value(NULL), creator(Creator) + : name(Name), hook(NULL), value(NULL), creator(Creator) { if (!dynrefs) - dynrefs = new intrusive_list; + dynrefs = new insp::intrusive_list; dynrefs->push_front(this); - if (dynref_init_complete) + + // Resolve unless there is no ModuleManager (part of class InspIRCd) + if (ServerInstance) resolve(); } @@ -696,19 +635,48 @@ void dynamic_reference_base::SetProvider(const std::string& newname) void dynamic_reference_base::resolve() { - std::multimap::iterator i = ServerInstance->Modules->DataProviders.find(name); - if (i != ServerInstance->Modules->DataProviders.end()) - value = static_cast(i->second); + // Because find() may return any element with a matching key in case count(key) > 1 use lower_bound() + // to ensure a dynref with the same name as another one resolves to the same object + std::multimap::iterator i = ServerInstance->Modules.DataProviders.lower_bound(name); + if ((i != ServerInstance->Modules.DataProviders.end()) && (i->first == this->name)) + { + ServiceProvider* newvalue = i->second; + if (value != newvalue) + { + value = newvalue; + if (hook) + hook->OnCapture(); + } + } else value = NULL; } Module* ModuleManager::Find(const std::string &name) { - std::map::iterator modfind = Modules.find(name); + std::map::const_iterator modfind = Modules.find(ExpandModName(name)); if (modfind == Modules.end()) return NULL; else return modfind->second; } + +void ModuleManager::AddReferent(const std::string& name, ServiceProvider* service) +{ + DataProviders.insert(std::make_pair(name, service)); + dynamic_reference_base::reset_all(); +} + +void ModuleManager::DelReferent(ServiceProvider* service) +{ + for (std::multimap::iterator i = DataProviders.begin(); i != DataProviders.end(); ) + { + ServiceProvider* curr = i->second; + if (curr == service) + DataProviders.erase(i++); + else + ++i; + } + dynamic_reference_base::reset_all(); +}