*/
+#include <fstream>
#include "inspircd.h"
#include "xline.h"
#include "socket.h"
#include "socketengine.h"
#include "command_parse.h"
-#include "dns.h"
#include "exitcodes.h"
#ifndef _WIN32
{
}
-Request::Request(Module* src, Module* dst, const char* idstr)
-: id(idstr), source(src), dest(dst)
-{
-}
-
-void Request::Send()
-{
- if (dest)
- dest->OnRequest(*this);
-}
-
Event::Event(Module* src, const std::string &eventid) : source(src), id(eventid) { }
void Event::Send()
{
- FOREACH_MOD(I_OnEvent,OnEvent(*this));
+ FOREACH_MOD(OnEvent, (*this));
}
// These declarations define the behavours of the base class Module (which does nothing at all)
void Module::OnPreRehash(User*, const std::string&) { }
void Module::OnModuleRehash(User*, const std::string&) { }
void Module::OnRehash(User*) { }
-ModResult Module::OnUserPreJoin(User*, Channel*, const std::string&, std::string&, const std::string&) { return MOD_RES_PASSTHRU; }
-void Module::OnMode(User*, void*, int, const std::vector<std::string>&, const std::vector<TranslateType>&) { }
+ModResult Module::OnUserPreJoin(LocalUser*, Channel*, const std::string&, std::string&, const std::string&) { return MOD_RES_PASSTHRU; }
+void Module::OnMode(User*, User*, Channel*, const std::vector<std::string>&, const std::vector<TranslateType>&) { }
void Module::OnOper(User*, const std::string&) { }
void Module::OnPostOper(User*, const std::string&, const std::string &) { }
void Module::OnInfo(User*) { }
void Module::OnWhois(User*, User*) { }
ModResult Module::OnUserPreInvite(User*, User*, Channel*, time_t) { return MOD_RES_PASSTHRU; }
-ModResult Module::OnUserPreMessage(User*, void*, int, std::string&, char, CUList&) { return MOD_RES_PASSTHRU; }
-ModResult Module::OnUserPreNotice(User*, void*, int, std::string&, char, CUList&) { return MOD_RES_PASSTHRU; }
+ModResult Module::OnUserPreMessage(User*, void*, int, std::string&, char, CUList&, MessageType) { return MOD_RES_PASSTHRU; }
ModResult Module::OnUserPreNick(User*, const std::string&) { return MOD_RES_PASSTHRU; }
void Module::OnUserPostNick(User*, const std::string&) { }
ModResult Module::OnPreMode(User*, User*, Channel*, const std::vector<std::string>&) { return MOD_RES_PASSTHRU; }
void Module::OnUnloadModule(Module*) { }
void Module::OnBackgroundTimer(time_t) { }
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::OnPostCommand(Command*, 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::OnChangeLocalUserGECOS(LocalUser*, const std::string&) { return MOD_RES_PASSTHRU; }
ModResult Module::OnPreTopicChange(User*, Channel*, const std::string&) { return MOD_RES_PASSTHRU; }
void Module::OnEvent(Event&) { }
-void Module::OnRequest(Request&) { }
ModResult Module::OnPassCompare(Extensible* ex, const std::string &password, const std::string &input, const std::string& hashtype) { return MOD_RES_PASSTHRU; }
void Module::OnGlobalOper(User*) { }
void Module::OnPostConnect(User*) { }
-void Module::OnStreamSocketAccept(StreamSocket*, irc::sockets::sockaddrs*, irc::sockets::sockaddrs*) { }
-int Module::OnStreamSocketWrite(StreamSocket*, std::string&) { return -1; }
-void Module::OnStreamSocketClose(StreamSocket*) { }
-void Module::OnStreamSocketConnect(StreamSocket*) { }
-int Module::OnStreamSocketRead(StreamSocket*, std::string&) { return -1; }
-void Module::OnUserMessage(User*, void*, int, const std::string&, char, const CUList&) { }
-void Module::OnUserNotice(User*, void*, int, const std::string&, char, const CUList&) { }
-void Module::OnRemoteKill(User*, User*, const std::string&, const std::string&) { }
+void Module::OnUserMessage(User*, void*, int, const std::string&, char, const CUList&, MessageType) { }
void Module::OnUserInvite(User*, User*, Channel*, time_t) { }
void Module::OnPostTopicChange(User*, Channel*, const std::string&) { }
void Module::OnGetServerDescription(const std::string&, std::string&) { }
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&) { }
-void Module::OnWallops(User*, const std::string&) { }
void Module::OnChangeHost(User*, const std::string&) { }
void Module::OnChangeName(User*, const std::string&) { }
void Module::OnChangeIdent(User*, const std::string&) { }
{
std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
- if (modfind == Modules.end() || modfind->second != mod)
+ if ((modfind == Modules.end()) || (modfind->second != mod) || (mod->dying))
{
LastModuleError = "Module " + mod->ModuleSourceFile + " is not loaded, cannot unload it!";
ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, LastModuleError);
ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, LastModuleError);
return false;
}
+
+ mod->dying = true;
return true;
}
// First, notify all modules that a module is about to be unloaded, so in case
// they pass execution to the soon to be unloaded module, it will happen now,
// i.e. before we unregister the services of the module being unloaded
- FOREACH_MOD(I_OnUnloadModule,OnUnloadModule(mod));
+ FOREACH_MOD(OnUnloadModule, (mod));
std::map<std::string, Module*>::iterator modfind = Modules.find(mod->ModuleSourceFile);
dynamic_reference_base::reset_all();
- /* Tidy up any dangling resolvers */
- ServerInstance->Res->CleanResolvers(mod);
-
DetachAll(mod);
Modules.erase(modfind);
ServerInstance->GlobalCulls.AddItem(mod);
- ServerInstance->Logs->Log("MODULE", LOG_DEFAULT,"Module %s unloaded",mod->ModuleSourceFile.c_str());
+ ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Module %s unloaded",mod->ModuleSourceFile.c_str());
this->ModCount--;
ServerInstance->ISupport.Build();
}
throw ModuleException("Command "+std::string(item.name)+" already exists.");
return;
case SERVICE_MODE:
- if (!ServerInstance->Modes->AddMode(static_cast<ModeHandler*>(&item)))
+ {
+ ModeHandler* mh = static_cast<ModeHandler*>(&item);
+ if (!ServerInstance->Modes->AddMode(mh))
throw ModuleException("Mode "+std::string(item.name)+" already exists.");
- DataProviders.insert(std::make_pair("mode/" + item.name, &item));
+ 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<ExtensionItem*>(&item)))
throw ModuleException("Extension " + std::string(item.name) + " already exists.");
case SERVICE_DATA:
case SERVICE_IOHOOK:
{
- if (item.name.substr(0, 5) == "mode/")
- throw ModuleException("The \"mode/\" service name prefix is reserved.");
+ if ((item.name.substr(0, 5) == "mode/") || (item.name.substr(0, 6) == "umode/"))
+ throw ModuleException("The \"mode/\" and the \"umode\" service name prefixes are reserved.");
DataProviders.insert(std::make_pair(item.name, &item));
std::string::size_type slash = item.name.find('/');
value = NULL;
}
-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)
- return this->Res->AddResolverClass(r);
- else
- {
- r->TriggerCachedResult();
- delete r;
- return true;
- }
-}
-
Module* ModuleManager::Find(const std::string &name)
{
std::map<std::string, Module*>::iterator modfind = Modules.find(name);
return retval;
}
-FileReader::FileReader(const std::string &filename)
-{
- LoadFile(filename);
-}
-
-FileReader::FileReader()
+FileReader::FileReader(const std::string& filename)
{
+ Load(filename);
}
-std::string FileReader::Contents()
+void FileReader::Load(const std::string& filename)
{
- std::string x;
- for (file_cache::iterator a = this->fc.begin(); a != this->fc.end(); a++)
+ // If the file is stored in the file cache then we used that version instead.
+ ConfigFileCache::iterator it = ServerInstance->Config->Files.find(filename);
+ if (it != ServerInstance->Config->Files.end())
{
- x.append(*a);
- x.append("\r\n");
- }
- return x;
-}
-
-unsigned long FileReader::ContentSize()
-{
- return this->contentsize;
-}
-
-void FileReader::CalcSize()
-{
- unsigned long n = 0;
- for (file_cache::iterator a = this->fc.begin(); a != this->fc.end(); a++)
- n += (a->length() + 2);
- this->contentsize = n;
-}
-
-void FileReader::LoadFile(const std::string &filename)
-{
- std::map<std::string, file_cache>::iterator file = ServerInstance->Config->Files.find(filename);
- if (file != ServerInstance->Config->Files.end())
- {
- this->fc = file->second;
+ this->lines = it->second;
}
else
{
- 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();
-}
+ lines.clear();
+ std::ifstream stream(filename.c_str());
+ if (!stream.is_open())
+ throw CoreException(filename + " does not exist or is not readable!");
-FileReader::~FileReader()
-{
-}
-
-bool FileReader::Exists()
-{
- return (!(fc.size() == 0));
-}
+ std::string line;
+ while (std::getline(stream, line))
+ {
+ lines.push_back(line);
+ totalSize += line.size() + 2;
+ }
-std::string FileReader::GetLine(int x)
-{
- if ((x<0) || ((unsigned)x>fc.size()))
- return "";
- return fc[x];
+ stream.close();
+ }
}
-int FileReader::FileSize()
+std::string FileReader::GetString()
{
- return fc.size();
+ std::string buffer;
+ for (file_cache::iterator it = this->lines.begin(); it != this->lines.end(); ++it)
+ {
+ buffer.append(*it);
+ buffer.append("\r\n");
+ }
+ return buffer;
}
projects / user / henk / code / inspircd.git / blobdiff