X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules.cpp;h=18f2dc4d1248dc6a59396a429e8bec71ecd4be17;hb=0ca92e252e5a22f3378f1a6d621fee878fcbf09d;hp=d7aa534ab4b22ddf7fdfea45f87375b2bf7f1b9c;hpb=ae10286658d6bb70e5e22526a004ec1b233f6fba;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules.cpp b/src/modules.cpp index d7aa534ab..18f2dc4d1 100644 --- a/src/modules.cpp +++ b/src/modules.cpp @@ -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() { } @@ -90,7 +83,6 @@ void Module::OnMode(User*, User*, Channel*, const Modes::ChangeList&, ModeParse 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; } @@ -115,15 +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::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); } @@ -139,15 +130,14 @@ void Module::OnCleanup(int, void*) { } 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 @@ -197,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) @@ -349,12 +337,6 @@ 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; @@ -469,26 +451,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) @@ -499,14 +461,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 if (callback) - callback->Call(false); -} - void ModuleManager::LoadAll() { std::map servicemap; @@ -517,7 +471,7 @@ void ModuleManager::LoadAll() { ConfigTag* tag = i->second; std::string name = tag->getString("name"); - this->NewServices = &servicemap[name]; + this->NewServices = &servicemap[ExpandModName(name)]; std::cout << "[" << con_green << "*" << con_reset << "] Loading module:\t" << con_green << name << con_reset << std::endl; if (!this->Load(name, true)) @@ -574,22 +528,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: { @@ -607,7 +545,7 @@ void ModuleManager::AddService(ServiceProvider& item) return; } default: - throw ModuleException("Cannot add unknown service type"); + item.RegisterService(); } } @@ -622,13 +560,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: @@ -654,8 +586,18 @@ 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 insp::intrusive_list; @@ -684,19 +626,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(); +}