X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmodules.cpp;h=de2fe96b3c59d6489607033bc2d7632ea615f658;hb=d23c030c9a8fd58807438245a004e4aa5b7288ba;hp=edcb243e27b93e4243ff50214d7fd44aeff4e122;hpb=a2860d06e429f35a4bacf4ea8a01eeeed1472285;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules.cpp b/src/modules.cpp index edcb243e2..de2fe96b3 100644 --- a/src/modules.cpp +++ b/src/modules.cpp @@ -32,13 +32,13 @@ #include #endif -static intrusive_list* dynrefs = NULL; +static insp::intrusive_list* dynrefs = NULL; void dynamic_reference_base::reset_all() { 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(); } @@ -52,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() { } @@ -86,16 +79,15 @@ 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::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(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); } @@ -115,16 +107,14 @@ 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::OnStats(Stats::Context&) { 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::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::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); } @@ -136,19 +126,18 @@ 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); } 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); } #ifdef INSPIRCD_ENABLE_TESTSUITE @@ -165,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() @@ -183,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); @@ -192,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) @@ -209,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) @@ -361,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 @@ -381,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 */ @@ -389,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(); @@ -402,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++; @@ -481,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) @@ -511,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; @@ -528,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()); @@ -586,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: { @@ -619,7 +550,7 @@ void ModuleManager::AddService(ServiceProvider& item) return; } default: - throw ModuleException("Cannot add unknown service type"); + item.RegisterService(); } } @@ -634,13 +565,7 @@ 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: @@ -666,11 +591,21 @@ 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); // Resolve unless there is no ModuleManager (part of class InspIRCd) @@ -696,19 +631,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(); +}