* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * InspIRCd: (C) 2002-2009 InspIRCd Development Team
+ * InspIRCd: (C) 2002-2010 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
// Version is a simple class for holding a modules version number
template<>
-VersionBase<API_VERSION>::VersionBase(const std::string &modv, int flags, const std::string& rev)
-: description(modv), version(rev), Flags(flags)
+VersionBase<API_VERSION>::VersionBase(const std::string &desc, int flags)
+: description(desc), Flags(flags)
{
}
+template<>
+VersionBase<API_VERSION>::VersionBase(const std::string &desc, int flags, const std::string& linkdata)
+: description(desc), Flags(flags), link_data(linkdata)
+{
+}
+
+template<>
+bool VersionBase<API_VERSION>::CanLink(const std::string& other_data)
+{
+ return link_data == other_data;
+}
+
Request::Request(Module* src, Module* dst, const char* idstr)
: id(idstr), source(src), dest(dst)
{
void Module::OnLoadModule(Module*) { }
void Module::OnUnloadModule(Module*) { }
void Module::OnBackgroundTimer(time_t) { }
-ModResult Module::OnPreCommand(std::string&, std::vector<std::string>&, User *, bool, const std::string&) { return MOD_RES_PASSTHRU; }
-void Module::OnPostCommand(const std::string&, const std::vector<std::string>&, User *, CmdResult, const std::string&) { }
+ModResult Module::OnPreCommand(std::string&, std::vector<std::string>&, LocalUser*, bool, const std::string&) { return MOD_RES_PASSTHRU; }
+void Module::OnPostCommand(const std::string&, const std::vector<std::string>&, LocalUser*, CmdResult, const std::string&) { }
+void Module::OnUserInit(LocalUser*) { }
ModResult Module::OnCheckReady(LocalUser*) { return MOD_RES_PASSTHRU; }
ModResult Module::OnUserRegister(LocalUser*) { return MOD_RES_PASSTHRU; }
ModResult Module::OnUserPreKick(User*, Membership*, const std::string&) { return MOD_RES_PASSTHRU; }
ModResult Module::OnWhoisLine(User*, User*, int&, std::string&) { return MOD_RES_PASSTHRU; }
void Module::OnBuildNeighborList(User*, UserChanList&, std::map<User*,bool>&) { }
void Module::OnGarbageCollect() { }
+ModResult Module::OnSetConnectClass(LocalUser* user, ConnectClass* myclass) { return MOD_RES_PASSTHRU; }
void Module::OnText(User*, void*, int, const std::string&, char, CUList&) { }
void Module::OnRunTestSuite() { }
void Module::OnNamesListItem(User*, Membership*, std::string&, std::string&) { }
ModResult Module::OnNumeric(User*, unsigned int, const std::string&) { return MOD_RES_PASSTHRU; }
void Module::OnHookIO(StreamSocket*, ListenSocket*) { }
ModResult Module::OnAcceptConnection(int, ListenSocket*, irc::sockets::sockaddrs*, irc::sockets::sockaddrs*) { return MOD_RES_PASSTHRU; }
-void Module::OnSendWhoLine(User*, User*, Channel*, std::string&) { }
+void Module::OnSendWhoLine(User*, const std::vector<std::string>&, User*, Channel*, std::string&) { }
ModResult Module::OnChannelRestrictionApply(User*, Channel*, const char*) { return MOD_RES_PASSTHRU; }
ModuleManager::ModuleManager() : ModCount(0)
bool ModuleManager::Attach(Implementation i, Module* mod)
{
+ if (Modules.find(mod->ModuleSourceFile) == Modules.end())
+ ServerInstance->Logs->Log("MODULE", DEFAULT, "Module is attaching to hook %d in constructor; this does not handle exceptions correctly!", i);
+
if (std::find(EventHandlers[i].begin(), EventHandlers[i].end(), mod) != EventHandlers[i].end())
return false;
return true;
}
-std::string& ModuleManager::LastError()
+bool ModuleManager::CanUnload(Module* mod)
{
- return LastModuleError;
-}
+ std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
-bool ModuleManager::PublishFeature(const std::string &FeatureName, Module* Mod)
-{
- if (Features.find(FeatureName) == Features.end())
+ if (modfind == Modules.end() || modfind->second != mod)
{
- Features[FeatureName] = Mod;
- return true;
+ LastModuleError = "Module " + mod->ModuleSourceFile + " is not loaded, cannot unload it!";
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
+ return false;
}
- return false;
-}
-
-bool ModuleManager::UnpublishFeature(const std::string &FeatureName)
-{
- featurelist::iterator iter = Features.find(FeatureName);
-
- if (iter == Features.end())
+ if (mod->GetVersion().Flags & VF_STATIC)
+ {
+ LastModuleError = "Module " + mod->ModuleSourceFile + " not unloadable (marked static)";
+ ServerInstance->Logs->Log("MODULE", DEFAULT, LastModuleError);
return false;
-
- Features.erase(iter);
+ }
return true;
}
-Module* ModuleManager::FindFeature(const std::string &FeatureName)
-{
- featurelist::iterator iter = Features.find(FeatureName);
-
- if (iter == Features.end())
- return NULL;
-
- return iter->second;
-}
-
-bool ModuleManager::PublishInterface(const std::string &InterfaceName, Module* Mod)
+void ModuleManager::DoSafeUnload(Module* mod)
{
- interfacelist::iterator iter = Interfaces.find(InterfaceName);
+ std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
- if (iter == Interfaces.end())
+ std::vector<reference<ExtensionItem> > items;
+ ServerInstance->Extensions.BeginUnregister(modfind->second, items);
+ /* Give the module a chance to tidy out all its metadata */
+ for (chan_hash::iterator c = ServerInstance->chanlist->begin(); c != ServerInstance->chanlist->end(); c++)
{
- modulelist ml;
- ml.push_back(Mod);
- Interfaces[InterfaceName] = std::make_pair(0, ml);
+ mod->OnCleanup(TYPE_CHANNEL,c->second);
+ c->second->doUnhookExtensions(items);
+ const UserMembList* users = c->second->GetUsers();
+ for(UserMembCIter mi = users->begin(); mi != users->end(); mi++)
+ mi->second->doUnhookExtensions(items);
}
- else
+ for (user_hash::iterator u = ServerInstance->Users->clientlist->begin(); u != ServerInstance->Users->clientlist->end(); u++)
{
- iter->second.second.push_back(Mod);
+ mod->OnCleanup(TYPE_USER,u->second);
+ u->second->doUnhookExtensions(items);
}
- return true;
-}
+ for(char m='A'; m <= 'z'; m++)
+ {
+ ModeHandler* mh;
+ mh = ServerInstance->Modes->FindMode(m, MODETYPE_USER);
+ if (mh && mh->creator == mod)
+ ServerInstance->Modes->DelMode(mh);
+ mh = ServerInstance->Modes->FindMode(m, MODETYPE_CHANNEL);
+ if (mh && mh->creator == mod)
+ ServerInstance->Modes->DelMode(mh);
+ }
+ for(std::multimap<std::string, ServiceProvider*>::iterator i = DataProviders.begin(); i != DataProviders.end(); )
+ {
+ std::multimap<std::string, ServiceProvider*>::iterator curr = i++;
+ if (curr->second->creator == mod)
+ DataProviders.erase(curr);
+ }
+ for(unsigned int i = 0; i < ServerInstance->Modules->ActiveDynrefs.size(); i++)
+ ServerInstance->Modules->ActiveDynrefs[i]->ClearCache();
-bool ModuleManager::UnpublishInterface(const std::string &InterfaceName, Module* Mod)
-{
- interfacelist::iterator iter = Interfaces.find(InterfaceName);
+ /* Tidy up any dangling resolvers */
+ ServerInstance->Res->CleanResolvers(mod);
- if (iter == Interfaces.end())
- return false;
+ FOREACH_MOD(I_OnUnloadModule,OnUnloadModule(mod));
- for (modulelist::iterator x = iter->second.second.begin(); x != iter->second.second.end(); x++)
- {
- if (*x == Mod)
- {
- iter->second.second.erase(x);
- if (iter->second.second.empty())
- Interfaces.erase(InterfaceName);
- return true;
- }
- }
- return false;
-}
+ DetachAll(mod);
-modulelist* ModuleManager::FindInterface(const std::string &InterfaceName)
-{
- interfacelist::iterator iter = Interfaces.find(InterfaceName);
- if (iter == Interfaces.end())
- return NULL;
- else
- return &(iter->second.second);
+ Modules.erase(modfind);
+ ServerInstance->GlobalCulls.AddItem(mod);
+
+ ServerInstance->Logs->Log("MODULE", DEFAULT,"Module %s unloaded",mod->ModuleSourceFile.c_str());
+ this->ModCount--;
+ ServerInstance->BuildISupport();
}
-bool ModuleManager::ModuleHasInterface(Module* mod, const std::string& InterfaceName)
+std::string& ModuleManager::LastError()
{
- interfacelist::iterator iter = Interfaces.find(InterfaceName);
- if (iter == Interfaces.end())
- return false;
- else
- {
- modulelist& ml = iter->second.second;
- modulelist::iterator mi = std::find(ml.begin(), ml.end(), mod);
- return (mi != ml.end());
- }
+ return LastModuleError;
}
-void ModuleManager::UseInterface(const std::string &InterfaceName)
+CmdResult InspIRCd::CallCommandHandler(const std::string &commandname, const std::vector<std::string>& parameters, User* user)
{
- interfacelist::iterator iter = Interfaces.find(InterfaceName);
- if (iter != Interfaces.end())
- iter->second.first++;
-
+ return this->Parser->CallHandler(commandname, parameters, user);
}
-void ModuleManager::DoneWithInterface(const std::string &InterfaceName)
+bool InspIRCd::IsValidModuleCommand(const std::string &commandname, int pcnt, User* user)
{
- interfacelist::iterator iter = Interfaces.find(InterfaceName);
- if (iter != Interfaces.end())
- iter->second.first--;
+ return this->Parser->IsValidCommand(commandname, pcnt, user);
}
-std::pair<int,std::string> ModuleManager::GetInterfaceInstanceCount(Module* m)
+void ModuleManager::AddService(ServiceProvider& item)
{
- for (interfacelist::iterator iter = Interfaces.begin(); iter != Interfaces.end(); iter++)
+ Module* owner = item.creator;
+ if (Modules.find(owner->ModuleSourceFile) == Modules.end())
+ ServerInstance->Logs->Log("MODULE", DEFAULT, "Module is registering item %s in constructor; this does not handle exceptions correctly!", item.name.c_str());
+
+ switch (item.service)
{
- for (modulelist::iterator x = iter->second.second.begin(); x != iter->second.second.end(); x++)
+ case SERVICE_COMMAND:
+ if (!ServerInstance->Parser->AddCommand(static_cast<Command*>(&item)))
+ throw ModuleException("Command "+std::string(item.name)+" already exists.");
+ return;
+ case SERVICE_MODE:
+ if (!ServerInstance->Modes->AddMode(static_cast<ModeHandler*>(&item)))
+ throw ModuleException("Mode "+std::string(item.name)+" already exists.");
+ return;
+ case SERVICE_METADATA:
+ ServerInstance->Extensions.Register(static_cast<ExtensionItem*>(&item));
+ return;
+ case SERVICE_DATA:
+ case SERVICE_IOHOOK:
{
- if (*x == m)
+ DataProviders.insert(std::make_pair(item.name, &item));
+ std::string::size_type slash = item.name.find('/');
+ if (slash != std::string::npos)
{
- return std::make_pair(iter->second.first, iter->first);
+ DataProviders.insert(std::make_pair(item.name.substr(0, slash), &item));
+ DataProviders.insert(std::make_pair(item.name.substr(slash + 1), &item));
}
+ return;
}
+ default:
+ throw ModuleException("Cannot add unknown service type");
}
- return std::make_pair(0, "");
}
-const std::string& ModuleManager::GetModuleName(Module* m)
+ServiceProvider* ModuleManager::FindService(ServiceType type, const std::string& name)
{
- static std::string nothing;
-
- for (std::map<std::string, Module*>::iterator n = Modules.begin(); n != Modules.end(); ++n)
+ switch (type)
{
- if (n->second == m)
- return n->first;
+ case SERVICE_DATA:
+ case SERVICE_IOHOOK:
+ {
+ std::multimap<std::string, ServiceProvider*>::iterator i = DataProviders.find(name);
+ if (i != DataProviders.end() && i->second->service == type)
+ return i->second;
+ return NULL;
+ }
+ // TODO implement finding of the other types
+ default:
+ throw ModuleException("Cannot find unknown service type");
}
+}
- return nothing;
+dynamic_reference_base::dynamic_reference_base(Module* Creator, const std::string& Name)
+ : name(Name), value(NULL), creator(Creator)
+{
+ ServerInstance->Modules->ActiveDynrefs.push_back(this);
}
-CmdResult InspIRCd::CallCommandHandler(const std::string &commandname, const std::vector<std::string>& parameters, User* user)
+dynamic_reference_base::~dynamic_reference_base()
{
- return this->Parser->CallHandler(commandname, parameters, user);
+ for(unsigned int i = 0; i < ServerInstance->Modules->ActiveDynrefs.size(); i++)
+ {
+ if (ServerInstance->Modules->ActiveDynrefs[i] == this)
+ {
+ unsigned int last = ServerInstance->Modules->ActiveDynrefs.size() - 1;
+ if (i != last)
+ ServerInstance->Modules->ActiveDynrefs[i] = ServerInstance->Modules->ActiveDynrefs[last];
+ ServerInstance->Modules->ActiveDynrefs.erase(ServerInstance->Modules->ActiveDynrefs.begin() + last);
+ return;
+ }
+ }
}
-bool InspIRCd::IsValidModuleCommand(const std::string &commandname, int pcnt, User* user)
+void dynamic_reference_base::SetProvider(const std::string& newname)
{
- return this->Parser->IsValidCommand(commandname, pcnt, user);
+ name = newname;
+ ClearCache();
}
-void InspIRCd::AddCommand(Command *f)
+void dynamic_reference_base::lookup()
{
- if (!this->Parser->AddCommand(f))
- {
- throw ModuleException("Command "+std::string(f->name)+" already exists.");
- }
+ if (!*this)
+ throw ModuleException("Dynamic reference to '" + name + "' failed to resolve");
}
-void InspIRCd::AddService(providerbase& item)
+dynamic_reference_base::operator bool()
{
- switch (item.service)
+ if (!value)
{
- case SERVICE_COMMAND:
- if (!Parser->AddCommand(static_cast<Command*>(&item)))
- throw ModuleException("Command "+std::string(item.name)+" already exists.");
- return;
- case SERVICE_CMODE:
- case SERVICE_UMODE:
- if (!Modes->AddMode(static_cast<ModeHandler*>(&item)))
- throw ModuleException("Mode "+std::string(item.name)+" already exists.");
- return;
- case SERVICE_METADATA:
- Extensions.Register(static_cast<ExtensionItem*>(&item));
- return;
- case SERVICE_DATA:
- case SERVICE_IOHOOK:
- default:
- throw ModuleException("Cannot add unknown service type");
+ std::multimap<std::string, ServiceProvider*>::iterator i = ServerInstance->Modules->DataProviders.find(name);
+ if (i != ServerInstance->Modules->DataProviders.end())
+ value = static_cast<DataProvider*>(i->second);
}
+ return value;
}
void InspIRCd::SendMode(const std::vector<std::string>& parameters, User *user)
this->Modes->Process(parameters, user);
}
+
+void InspIRCd::SendGlobalMode(const std::vector<std::string>& parameters, User *user)
+{
+ Modes->Process(parameters, user);
+ if (!Modes->GetLastParse().empty())
+ this->PI->SendMode(parameters[0], Modes->GetLastParseParams(), Modes->GetLastParseTranslate());
+}
+
bool InspIRCd::AddResolver(Resolver* r, bool cached)
{
if (!cached)
ConfigReader::ConfigReader()
{
this->error = 0;
+ ServerInstance->Logs->Log("MODULE", DEBUG, "ConfigReader is deprecated in 2.0; "
+ "use ServerInstance->Config->ConfValue(\"key\") or ->ConfTags(\"key\") instead");
}
void FileReader::LoadFile(const std::string &filename)
{
- file_cache c;
- c.clear();
- if (ServerInstance->Config->ReadFile(c,filename.c_str()))
+ std::map<std::string, file_cache>::iterator file = ServerInstance->Config->Files.find(filename);
+ if (file != ServerInstance->Config->Files.end())
+ {
+ this->fc = file->second;
+ }
+ else
{
- this->fc = c;
- this->CalcSize();
+ fc.clear();
+ FILE* f = fopen(filename.c_str(), "r");
+ if (!f)
+ return;
+ char linebuf[MAXBUF*10];
+ while (fgets(linebuf, sizeof(linebuf), f))
+ {
+ int len = strlen(linebuf);
+ if (len)
+ fc.push_back(std::string(linebuf, len - 1));
+ }
+ fclose(f);
}
+ CalcSize();
}
projects / user / henk / code / inspircd.git / blobdiff