*/
class CoreExport BanCacheHit : public classbase
{
- private:
- InspIRCd *ServerInstance;
public:
/** Type of cached ban
*/
*/
time_t Expiry;
- BanCacheHit(InspIRCd *Instance, const std::string &ip, const std::string &type, const std::string &reason)
+ BanCacheHit(const std::string &ip, const std::string &type, const std::string &reason)
{
- ServerInstance = Instance;
this->Type = type;
this->Reason = reason;
this->IP = ip;
}
// overridden to allow custom time
- BanCacheHit(InspIRCd *Instance, const std::string &ip, const std::string &type, const std::string &reason, time_t seconds)
+ BanCacheHit(const std::string &ip, const std::string &type, const std::string &reason, time_t seconds)
{
- ServerInstance = Instance;
this->Type = type;
this->Reason = reason;
this->IP = ip;
{
private:
BanCacheHash* BanHash;
- InspIRCd* ServerInstance;
public:
/** Creates and adds a Ban Cache item.
*/
unsigned int RemoveEntries(const std::string &type, bool positive);
- BanCacheManager(InspIRCd *Instance)
+ BanCacheManager()
{
- this->ServerInstance = Instance;
this->BanHash = new BanCacheHash();
}
~BanCacheManager()
* parameters, to prevent mistakes.
*/
#define DEFINE_HANDLER0(NAME, RETURN) \
- class CoreExport NAME : public HandlerBase0<RETURN> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(); }
+ class CoreExport NAME : public HandlerBase0<RETURN> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(); }
#define DEFINE_HANDLER1(NAME, RETURN, V1) \
- class CoreExport NAME : public HandlerBase1<RETURN, V1> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1); }
+ class CoreExport NAME : public HandlerBase1<RETURN, V1> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1); }
#define DEFINE_HANDLER2(NAME, RETURN, V1, V2) \
- class CoreExport NAME : public HandlerBase2<RETURN, V1, V2> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1, V2); }
+ class CoreExport NAME : public HandlerBase2<RETURN, V1, V2> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1, V2); }
#define DEFINE_HANDLER3(NAME, RETURN, V1, V2, V3) \
- class CoreExport NAME : public HandlerBase3<RETURN, V1, V2, V3> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3); }
+ class CoreExport NAME : public HandlerBase3<RETURN, V1, V2, V3> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3); }
#define DEFINE_HANDLER4(NAME, RETURN, V1, V2, V3, V4) \
- class CoreExport NAME : public HandlerBase4<RETURN, V1, V2, V3, V4> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4); }
+ class CoreExport NAME : public HandlerBase4<RETURN, V1, V2, V3, V4> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4); }
#define DEFINE_HANDLER5(NAME, RETURN, V1, V2, V3, V4, V5) \
- class CoreExport NAME : public HandlerBase5<RETURN, V1, V2, V3, V4, V5> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5); }
+ class CoreExport NAME : public HandlerBase5<RETURN, V1, V2, V3, V4, V5> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5); }
#define DEFINE_HANDLER6(NAME, RETURN, V1, V2, V3, V4, V5, V6) \
- class CoreExport NAME : public HandlerBase6<RETURN, V1, V2, V3, V4, V5, V6> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6); }
+ class CoreExport NAME : public HandlerBase6<RETURN, V1, V2, V3, V4, V5, V6> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6); }
#define DEFINE_HANDLER7(NAME, RETURN, V1, V2, V3, V4, V5, V6, V7) \
- class CoreExport NAME : public HandlerBase7<RETURN, V1, V2, V3, V4, V5, V6, V7> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6, V7); }
+ class CoreExport NAME : public HandlerBase7<RETURN, V1, V2, V3, V4, V5, V6, V7> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6, V7); }
#define DEFINE_HANDLER8(NAME, RETURN, V1, V2, V3, V4, V5, V6, V7, V8) \
- class CoreExport NAME : public HandlerBase8<RETURN, V1, V2, V3, V4, V5, V6, V7, V8> { InspIRCd* Server; public: NAME(InspIRCd* Srv) : Server(Srv) { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6, V7, V8); }
+ class CoreExport NAME : public HandlerBase8<RETURN, V1, V2, V3, V4, V5, V6, V7, V8> { public: NAME() { } virtual ~NAME() { } virtual RETURN Call(V1, V2, V3, V4, V5, V6, V7, V8); }
#endif
*/
class CoreExport ChannelManager
{
- private:
- InspIRCd *ServerInstance;
public:
/** Constructor
*/
- ChannelManager(InspIRCd *Instance) : ServerInstance(Instance)
+ ChannelManager()
{
}
};
{
/** Connect a Channel to a User
*/
- static Channel* ForceChan(InspIRCd* Instance, Channel* Ptr, User* user, const std::string &privs, bool bursting, bool created);
+ static Channel* ForceChan(Channel* Ptr, User* user, const std::string &privs, bool bursting, bool created);
/** Set default modes for the channel on creation
*/
/** Creates a channel record and initialises it with default values
* @throw Nothing at present.
*/
- Channel(InspIRCd* Instance, const std::string &name, time_t ts);
+ Channel(const std::string &name, time_t ts);
/** The channel's name.
*/
* been created if the channel did not exist before the user was joined to it.
* If the user could not be joined to a channel, the return value may be NULL.
*/
- static Channel* JoinUser(InspIRCd* ServerInstance, User *user, const char* cn, bool override, const char* key, bool bursting, time_t TS = 0);
+ static Channel* JoinUser(User *user, const char* cn, bool override, const char* key, bool bursting, time_t TS = 0);
/** Write to a channel, from a user, using va_args for text
* @param user User whos details to prefix the line with
class CoreExport CommandParser : public classbase
{
private:
- /** The creator of this class
- */
- InspIRCd* ServerInstance;
-
/** Parameter buffer
*/
std::vector<std::string> para;
/** Default constructor.
* @param Instance The creator of this class
*/
- CommandParser(InspIRCd* Instance);
+ CommandParser();
/** Calls the handler for a given command.
* @param commandname The command to find. This should be in uppercase.
class WhoWasMaintainTimer : public Timer
{
- private:
- InspIRCd* ServerInstance;
public:
- WhoWasMaintainTimer(InspIRCd* Instance, long interval)
- : Timer(interval, Instance->Time(), true), ServerInstance(Instance)
+ WhoWasMaintainTimer(long interval)
+ : Timer(interval, ServerInstance->Time(), true)
{
}
virtual void Tick(time_t TIME);
/** Determines if a channel op is exempt from given mode m,
* in config of server instance s.
*/
-#define CHANOPS_EXEMPT(s, m) (s->Config->ExemptChanOps[(unsigned char)m])
+#define CHANOPS_EXEMPT(m) (ServerInstance->Config->ExemptChanOps[(unsigned char)m])
#include <sstream>
#include <string>
class CoreExport ServerConfig : public classbase
{
private:
- /** Creator/owner pointer
- */
- InspIRCd* ServerInstance;
-
/** This variable holds the names of all
* files included from the main one. This
* is used to make sure that no files are
/** Used to indicate who we announce invites to on a channel */
enum InviteAnnounceState { INVITE_ANNOUNCE_NONE, INVITE_ANNOUNCE_ALL, INVITE_ANNOUNCE_OPS, INVITE_ANNOUNCE_DYNAMIC };
- /** Returns the creator InspIRCd pointer
- */
- InspIRCd* GetInstance();
-
/** Not used any more as it is named, can probably be removed or renamed.
*/
int DoDownloads();
/** Construct a new ServerConfig
*/
- ServerConfig(InspIRCd* Instance);
+ ServerConfig();
/** Get server ID as string with required leading zeroes
*/
class CoreExport Resolver : public Extensible
{
protected:
- /**
- * Pointer to creator
- */
- InspIRCd* ServerInstance;
/**
* Pointer to creator module (if any, or NULL)
*/
* whilst lookups are in progress, they can be safely removed and your module will not
* crash the server.
*/
- Resolver(InspIRCd* Instance, const std::string &source, QueryType qt, bool &cached, Module* creator = NULL);
+ Resolver(const std::string &source, QueryType qt, bool &cached, Module* creator = NULL);
/**
* The default destructor does nothing.
{
private:
- /**
- * Creator/Owner object
- */
- InspIRCd* ServerInstance;
-
/**
* The maximum value of a dns request id,
* 16 bits wide, 0xFFFF.
* The constructor initialises the dns socket,
* and clears the request lists.
*/
- DNS(InspIRCd* Instance);
+ DNS();
/**
* Re-initialize the DNS subsystem.
public:
/** This constructor loads the module using dlopen()
- * @param ServerInstance The creator class of this object
* @param fname The filename to load. This should be within
* the modules dir.
*/
- DLLManager(InspIRCd* ServerInstance, const char *fname);
+ DLLManager(const char *fname);
virtual ~DLLManager();
/** Get a symbol using dynamic linking.
* The init_module function is the only exported extern "C" declaration
* in any module file. In a cmd_*.cpp file the equivilant is init_command
*/
- typedef ReturnType * (initfunctype) (InspIRCd*);
+ typedef ReturnType * (initfunctype) ();
/** Pointer to the init function.
*/
initfunctype* init_func;
- /** Instance pointer to be passed to init_*() when it is called.
- */
- InspIRCd* ServerInstance;
-
public:
/** Default constructor.
* This constructor passes its paramerers down through DLLFactoryBase and then DLLManager
* class. It is then down to the core to call the ModuleFactory::CreateModule() method and
* receive a Module* which it can insert into its module lists.
*/
- DLLFactory(InspIRCd* Instance, const char *fname, const char *func_name)
- : DLLManager(Instance, fname), init_func(NULL), ServerInstance(Instance)
+ DLLFactory(const char *fname, const char *func_name)
+ : DLLManager(fname), init_func(NULL)
{
const char* error = LastError();
{
if(init_func)
{
- return init_func(ServerInstance);
+ return init_func();
}
else
{
class CoreExport FakeUser : public User
{
public:
- FakeUser(InspIRCd* Instance, const std::string &uid) : User(Instance, uid)
+ FakeUser(const std::string &uid) : User(uid)
{
SetFd(FD_FAKEUSER_NUMBER);
}
private:
FileWriter *f;
public:
- FileLogStream(InspIRCd *Instance, int loglevel, FileWriter *fw);
+ FileLogStream(int loglevel, FileWriter *fw);
virtual ~FileLogStream();
class CoreExport modestacker : public classbase
{
private:
- InspIRCd* ServerInstance;
-
/** The mode sequence and its parameters
*/
std::deque<std::string> sequence;
* @param add True if the stack is adding modes,
* false if it is removing them
*/
- modestacker(InspIRCd* Instance, bool add);
+ modestacker(bool add);
/** Push a modeletter and its parameter onto the stack.
* No checking is performed as to if this mode actually
*/
class CoreExport ConfigReaderThread : public Thread
{
- InspIRCd* ServerInstance;
ServerConfig* Config;
bool done;
public:
std::string TheUserUID;
- ConfigReaderThread(InspIRCd* Instance, const std::string &useruid)
- : Thread(), ServerInstance(Instance), done(false), TheUserUID(useruid)
+ ConfigReaderThread(const std::string &useruid)
+ : Thread(), done(false), TheUserUID(useruid)
{
}
{
Cmd cmd;
public:
- CommandModule(InspIRCd*) : cmd(this)
+ CommandModule() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
class CoreExport FileWriter : public EventHandler
{
protected:
- /** The creator/owner of this object
- */
- InspIRCd* ServerInstance;
-
/** The log file (fd is inside this somewhere,
* we get it out with fileno())
*/
public:
/** The constructor takes an already opened logfile.
*/
- FileWriter(InspIRCd* Instance, FILE* logfile);
+ FileWriter(FILE* logfile);
/** Handle pending write events.
* This will flush any waiting data to disk.
class CoreExport LogStream : public classbase
{
protected:
- InspIRCd *ServerInstance;
int loglvl;
public:
- LogStream(InspIRCd *Instance, int loglevel) : ServerInstance(Instance), loglvl(loglevel)
+ LogStream(int loglevel) : loglvl(loglevel)
{
}
*/
LogStream* noforkstream;
- InspIRCd *ServerInstance;
-
/** Map of active log types and what LogStreams will receive them.
*/
std::map<std::string, std::vector<LogStream *> > LogStreams;
public:
- LogManager(InspIRCd *Instance)
+ LogManager()
{
noforkstream = NULL;
- ServerInstance = Instance;
Logging = false;
}
class CoreExport SimpleChannelModeHandler : public ModeHandler
{
public:
- SimpleChannelModeHandler(InspIRCd* Instance, Module* Creator, char modeletter)
+ SimpleChannelModeHandler(Module* Creator, char modeletter)
: ModeHandler(Creator, modeletter, PARAM_NONE, MODETYPE_CHANNEL) {}
virtual ~SimpleChannelModeHandler() {}
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
class CoreExport ModeWatcher : public classbase
{
protected:
- /**
- * Creator/owner pointer
- */
- InspIRCd* ServerInstance;
/**
* The mode letter this class is watching
*/
/**
* The constructor initializes the mode and the mode type
*/
- ModeWatcher(InspIRCd* Instance, char modeletter, ModeType type);
+ ModeWatcher(char modeletter, ModeType type);
/**
* The default destructor does nothing.
*/
/** The constructor initializes all the RFC basic modes by using ModeParserAddMode().
*/
- ModeParser(InspIRCd* Instance);
+ ModeParser();
~ModeParser();
/** Used to check if user 'd' should be allowed to do operation 'MASK' on channel 'chan'.
private:
BanItem b;
public:
- ModeChannelBan(InspIRCd* Instance);
+ ModeChannelBan();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
std::string& AddBan(User *user,std::string& dest,Channel *chan,int status);
std::string& DelBan(User *user,std::string& dest,Channel *chan,int status);
{
private:
public:
- ModeChannelHalfOp(InspIRCd* Instance);
+ ModeChannelHalfOp();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter);
unsigned int GetPrefixRank();
class ModeChannelInviteOnly : public SimpleChannelModeHandler
{
public:
- ModeChannelInviteOnly(InspIRCd* Instance);
+ ModeChannelInviteOnly();
};
class ModeChannelKey : public ModeHandler
{
public:
- ModeChannelKey(InspIRCd* Instance);
+ ModeChannelKey();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter);
void RemoveMode(Channel* channel, irc::modestacker* stack = NULL);
class ModeChannelLimit : public ModeHandler
{
public:
- ModeChannelLimit(InspIRCd* Instance);
+ ModeChannelLimit();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter);
bool CheckTimeStamp(std::string &their_param, const std::string &our_param, Channel* channel);
class ModeChannelModerated : public SimpleChannelModeHandler
{
public:
- ModeChannelModerated(InspIRCd* Instance);
+ ModeChannelModerated();
};
class ModeChannelNoExternal : public SimpleChannelModeHandler
{
public:
- ModeChannelNoExternal(InspIRCd* Instance);
+ ModeChannelNoExternal();
};
{
private:
public:
- ModeChannelOp(InspIRCd* Instance);
+ ModeChannelOp();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter);
unsigned int GetPrefixRank();
class ModeChannelPrivate : public SimpleChannelModeHandler
{
public:
- ModeChannelPrivate(InspIRCd* Instance);
+ ModeChannelPrivate();
};
class ModeChannelSecret : public SimpleChannelModeHandler
{
public:
- ModeChannelSecret(InspIRCd* Instance);
+ ModeChannelSecret();
};
class ModeChannelTopicOps : public ModeHandler
{
public:
- ModeChannelTopicOps(InspIRCd* Instance);
+ ModeChannelTopicOps();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
};
{
private:
public:
- ModeChannelVoice(InspIRCd* Instance);
+ ModeChannelVoice();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter);
unsigned int GetPrefixRank();
class ModeUserInvisible : public SimpleUserModeHandler
{
public:
- ModeUserInvisible(InspIRCd* Instance);
+ ModeUserInvisible();
unsigned int GetCount();
};
class ModeUserOperator : public ModeHandler
{
public:
- ModeUserOperator(InspIRCd* Instance);
+ ModeUserOperator();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
unsigned int GetCount();
};
class ModeUserServerNoticeMask : public ModeHandler
{
public:
- ModeUserServerNoticeMask(InspIRCd* Instance);
+ ModeUserServerNoticeMask();
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
void OnParameterMissing(User* user, User* dest, Channel* channel);
std::string GetUserParameter(User* user);
class ModeUserWallops : public SimpleUserModeHandler
{
public:
- ModeUserWallops(InspIRCd* Instance);
+ ModeUserWallops();
unsigned int GetCount();
};
} \
} while (0);
-/**
- * This #define allows us to call a method in all
- * loaded modules in a readable simple way and pass
- * an instance pointer to the macro. e.g.:
- * 'FOREACH_MOD_I(Instance, OnConnect, OnConnect(user));'
- */
-#define FOREACH_MOD_I(z,y,x) do { \
- EventHandlerIter safei; \
- for (EventHandlerIter _i = z->Modules->EventHandlers[y].begin(); _i != z->Modules->EventHandlers[y].end(); ) \
- { \
- safei = _i; \
- ++safei; \
- try \
- { \
- (*_i)->x ; \
- } \
- catch (CoreException& modexcept) \
- { \
- z->Logs->Log("MODULE",DEFAULT,"Exception caught: %s",modexcept.GetReason()); \
- } \
- _i = safei; \
- } \
-} while (0);
-
/**
* Custom module result handling loop. This is a paired macro, and should only
* be used with while_each_hook.
*
* See src/channels.cpp for an example of use.
*/
-#define DO_EACH_HOOK(z,n,v,args) \
+#define DO_EACH_HOOK(n,v,args) \
do { \
- EventHandlerIter iter_ ## n = z->Modules->EventHandlers[I_ ## n].begin(); \
- while (iter_ ## n != z->Modules->EventHandlers[I_ ## n].end()) \
+ EventHandlerIter iter_ ## n = ServerInstance->Modules->EventHandlers[I_ ## n].begin(); \
+ while (iter_ ## n != ServerInstance->Modules->EventHandlers[I_ ## n].end()) \
{ \
Module* mod_ ## n = *iter_ ## n; \
iter_ ## n ++; \
{ \
v = (mod_ ## n)->n args;
-#define WHILE_EACH_HOOK(z,n) \
+#define WHILE_EACH_HOOK(n) \
} \
catch (CoreException& except_ ## n) \
{ \
- z->Logs->Log("MODULE",DEFAULT,"Exception caught: %s", (except_ ## n).GetReason()); \
+ ServerInstance->Logs->Log("MODULE",DEFAULT,"Exception caught: %s", (except_ ## n).GetReason()); \
(void) mod_ ## n; /* catch mismatched pairs */ \
} \
} \
* Runs the given hook until some module returns a useful result.
*
* Example: ModResult result;
- * FIRST_MOD_RESULT(ServerInstance, OnUserPreNick, result, (user, newnick))
+ * FIRST_MOD_RESULT(OnUserPreNick, result, (user, newnick))
*/
-#define FIRST_MOD_RESULT(z,n,v,args) do { \
+#define FIRST_MOD_RESULT(n,v,args) do { \
v = MOD_RES_PASSTHRU; \
- DO_EACH_HOOK(z,n,v,args) \
+ DO_EACH_HOOK(n,v,args) \
{ \
if (v != MOD_RES_PASSTHRU) \
break; \
} \
- WHILE_EACH_HOOK(z,n); \
+ WHILE_EACH_HOOK(n); \
} while (0)
/** Represents a non-local user.
* The return result of an Event::Send() will always be NULL as
* no replies are expected.
*/
- char* Send(InspIRCd* ServerInstance);
+ char* Send();
};
/** Priority types which can be returned from Module::Prioritize()
* @param Me An instance of the InspIRCd class which will be saved into ServerInstance for your use
* \exception ModuleException Throwing this class, or any class derived from ModuleException, causes loading of the module to abort.
*/
- Module(InspIRCd* Me = ServerInstance);
+ Module();
/** Default destructor.
* destroys a module class
* This constructor initialises the ConfigReader class to read the inspircd.conf file
* as specified when running ./configure.
*/
- ConfigReader(InspIRCd* Instance = ServerInstance);
+ ConfigReader();
/** Default destructor.
* This method destroys the ConfigReader class.
*/
* This method does not load any file into memory, you must use the LoadFile method
* after constructing the class this way.
*/
- FileReader(InspIRCd* Instance = ServerInstance);
+ FileReader();
/** Secondary constructor.
* This method initialises the class with a file loaded into it ready for GetLine and
* and other methods to be called. If the file could not be loaded, FileReader::FileSize
* returns 0.
*/
- FileReader(InspIRCd* Instance, const std::string &filename);
+ FileReader(const std::string &filename);
/** Default destructor.
* This deletes the memory allocated to the file.
#ifdef WINDOWS
#define MODULE_INIT(y) \
- extern "C" DllExport Module * init_module(InspIRCd* Me) \
+ extern "C" DllExport Module * init_module() \
{ \
- return new y(Me); \
+ return new y; \
} \
BOOLEAN WINAPI DllMain(HINSTANCE hDllHandle, DWORD nReason, LPVOID Reserved) \
{ \
#else
#define MODULE_INIT(y) \
- extern "C" DllExport Module * init_module(InspIRCd* Me) \
+ extern "C" DllExport Module * init_module() \
{ \
- return new y(Me); \
+ return new y; \
}
#endif
#include "hashcomp.h"
-class InspIRCd;
class User;
typedef std::vector<std::string> parameterlist;
class ProtocolInterface : public Extensible
{
- protected:
- InspIRCd* ServerInstance;
public:
- ProtocolInterface(InspIRCd* Instance) : ServerInstance(Instance) { }
+ ProtocolInterface() { }
virtual ~ProtocolInterface() { }
/** Send an ENCAP message to one or more linked servers.
class Snomask : public Extensible
{
- private:
- InspIRCd *ServerInstance;
-
public:
char MySnomask;
std::string Description;
/** Create a new Snomask
*/
- Snomask(InspIRCd* Instance, char snomask, const std::string &description) : ServerInstance(Instance), MySnomask(snomask), Description(description), LastMessage(""), Count(0)
+ Snomask(char snomask, const std::string &description) : MySnomask(snomask), Description(description), LastMessage(""), Count(0)
{
}
class CoreExport SnomaskManager
{
private:
- /** Creator/owner
- */
- InspIRCd* ServerInstance;
-
/** Currently active snomask list
*/
SnoList SnoMasks;
public:
/** Create a new SnomaskManager
*/
- SnomaskManager(InspIRCd* Instance);
+ SnomaskManager();
/** Delete SnomaskManager
*/
class CoreExport ListenSocketBase : public EventHandler
{
protected:
- /** The creator/owner of this object
- */
- InspIRCd* ServerInstance;
/** Socket description (shown in stats p) */
std::string desc;
public:
/** Create a new listening socket
*/
- ListenSocketBase(InspIRCd* Instance, int port, const std::string &addr);
+ ListenSocketBase(int port, const std::string &addr);
/** Handle an I/O event
*/
void HandleEvent(EventType et, int errornum = 0);
{
virtual void OnAcceptReady(int fd);
public:
- ClientListenSocket(InspIRCd* Instance, int port, const std::string &addr) : ListenSocketBase(Instance, port, addr) { }
+ ClientListenSocket(int port, const std::string &addr) : ListenSocketBase(port, addr) { }
};
#endif
#ifndef __TESTSUITE_H__
#define __TESTSUITE_H__
-class InspIRCd;
-
class TestSuite : public Extensible
{
- private:
- InspIRCd* ServerInstance;
public:
- TestSuite(InspIRCd* Instance);
+ TestSuite();
~TestSuite();
bool DoThreadTests();
*/
void NotifyParent();
public:
- SocketThread(InspIRCd* SI);
+ SocketThread();
virtual ~SocketThread();
/** Lock queue.
*/
#include "inspircd_config.h"
#include "base.h"
-class InspIRCd;
class Thread;
/** The ThreadEngine class has the responsibility of initialising
/** Constructor.
* @param Instance Creator object
*/
- ThreadEngine(InspIRCd* Instance);
+ ThreadEngine();
/** Destructor
*/
#include "inspircd_config.h"
#include "base.h"
-class InspIRCd;
class Thread;
/** The ThreadEngine class has the responsibility of initialising
{
public:
- ThreadEngine(InspIRCd* Instance);
+ ThreadEngine();
virtual ~ThreadEngine();
#ifndef INSPIRCD_TIMER_H
#define INSPIRCD_TIMER_H
-//class InspIRCd;
-
/** Timer class for one-second resolution timers
* Timer provides a facility which allows module
* developers to create one-shot timers. The timer
*/
std::vector<Timer *> Timers;
- /** Creating server instance
- */
- InspIRCd* ServerInstance;
public:
/** Constructor
*/
- TimerManager(InspIRCd* Instance);
+ TimerManager();
~TimerManager();
/** Tick all pending Timers
/** Get the time as a string
*/
-inline std::string stringtime(InspIRCd* Instance)
+inline std::string stringtime()
{
std::ostringstream TIME;
- TIME << Instance->Time();
+ TIME << ServerInstance->Time();
return TIME.str();
}
* @param autotidy Automatically tidy list entries on add
* @param ctag Configuration tag to get limits from
*/
- ListModeBase(InspIRCd* Instance, Module* Creator, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist")
+ ListModeBase(Module* Creator, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist")
: ModeHandler(Creator, modechar, PARAM_ALWAYS, MODETYPE_CHANNEL),
listnumeric(lnum), endoflistnumeric(eolnum), endofliststring(eolstr), tidy(autotidy),
configtag(ctag), extItem("listbase_mode_" + std::string(1, mode) + "_list", Creator)
modelist* el = extItem.get(channel);
if (el)
{
- irc::modestacker modestack(ServerInstance, false);
+ irc::modestacker modestack(false);
for (modelist::iterator it = el->begin(); it != el->end(); it++)
{
*/
virtual void DoRehash()
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
chanlimits.clear();
ListItem e;
e.mask = parameter;
e.nick = source->nick;
- e.time = stringtime(ServerInstance);
+ e.time = stringtime();
el->push_back(e);
return MODEACTION_ALLOW;
virtual void DoSyncChannel(Channel* chan, Module* proto, void* opaque)
{
modelist* mlist = extItem.get(chan);
- irc::modestacker modestack(ServerInstance, true);
+ irc::modestacker modestack(true);
std::vector<std::string> stackresult;
std::vector<TranslateType> types;
types.push_back(TR_TEXT);
class CoreExport UserManager : public Extensible
{
private:
- InspIRCd *ServerInstance;
-
/** Map of local ip addresses for clone counting
*/
clonemap local_clones;
public:
- UserManager(InspIRCd *Instance) : ServerInstance(Instance)
- {
- }
-
~UserManager()
{
for (user_hash::iterator i = clientlist->begin();i != clientlist->end();i++)
* @param server The server IP address and port used by the user
* @return This function has no return value, but a call to AddClient may remove the user.
*/
- void AddUser(InspIRCd* Instance, int socket, ClientListenSocket* via, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
+ void AddUser(int socket, ClientListenSocket* via, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
/** Disconnect a user gracefully
* @param user The user to remove
* @param Instance Creator instance
* @param uid User UUID, or empty to allocate one automatically
*/
- User(InspIRCd* Instance, const std::string &uid = "");
+ User(const std::string &uid = "");
/** Check if the user matches a G or K line, and disconnect them if they do.
* @param doZline True if ZLines should be checked (if IP has changed since initial connect)
* @param qt The query type
* @param cache Modified by the constructor if the result was cached
*/
- UserResolver(InspIRCd* Instance, User* user, std::string to_resolve, QueryType qt, bool &cache);
+ UserResolver(User* user, std::string to_resolve, QueryType qt, bool &cache);
/** Called on successful lookup
* @param result Result string
{
protected:
- /** Creator */
- InspIRCd* ServerInstance;
-
/** Default 'apply' action. Quits the user.
* @param u User to apply the line against
* @param line The line typed, used for display purposes in the quit message
* @param re The reason of the xline
* @param t The line type, should be set by the derived class constructor
*/
- XLine(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, const std::string &t)
- : ServerInstance(Instance), set_time(s_time), duration(d), source(src), reason(re), type(t)
+ XLine(time_t s_time, long d, std::string src, std::string re, const std::string &t)
+ : set_time(s_time), duration(d), source(src), reason(re), type(t)
{
expiry = set_time + duration;
}
* @param ident Ident to match
* @param host Host to match
*/
- KLine(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
- : XLine(Instance, s_time, d, src, re, "K"), identmask(ident), hostmask(host)
+ KLine(time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
+ : XLine(s_time, d, src, re, "K"), identmask(ident), hostmask(host)
{
matchtext = this->identmask;
matchtext.append("@").append(this->hostmask);
* @param ident Ident to match
* @param host Host to match
*/
- GLine(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
- : XLine(Instance, s_time, d, src, re, "G"), identmask(ident), hostmask(host)
+ GLine(time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
+ : XLine(s_time, d, src, re, "G"), identmask(ident), hostmask(host)
{
matchtext = this->identmask;
matchtext.append("@").append(this->hostmask);
* @param ident Ident to match
* @param host Host to match
*/
- ELine(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
- : XLine(Instance, s_time, d, src, re, "E"), identmask(ident), hostmask(host)
+ ELine(time_t s_time, long d, std::string src, std::string re, std::string ident, std::string host)
+ : XLine(s_time, d, src, re, "E"), identmask(ident), hostmask(host)
{
matchtext = this->identmask;
matchtext.append("@").append(this->hostmask);
* @param re The reason of the xline
* @param ip IP to match
*/
- ZLine(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string ip)
- : XLine(Instance, s_time, d, src, re, "Z"), ipaddr(ip)
+ ZLine(time_t s_time, long d, std::string src, std::string re, std::string ip)
+ : XLine(s_time, d, src, re, "Z"), ipaddr(ip)
{
}
* @param re The reason of the xline
* @param nickname Nickname to match
*/
- QLine(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string nickname)
- : XLine(Instance, s_time, d, src, re, "Q"), nick(nickname)
+ QLine(time_t s_time, long d, std::string src, std::string re, std::string nickname)
+ : XLine(s_time, d, src, re, "Q"), nick(nickname)
{
}
{
protected:
- InspIRCd* ServerInstance;
std::string type;
public:
* @param Instance creator
* @param t Type of XLine this factory generates
*/
- XLineFactory(InspIRCd* Instance, const std::string &t) : ServerInstance(Instance), type(t) { }
+ XLineFactory(const std::string &t) : type(t) { }
/** Return the type of XLine this factory generates
* @return The type of XLine this factory generates
/* Required forward declarations
*/
class ServerConfig;
-class InspIRCd;
class GLineFactory;
class ELineFactory;
class CoreExport XLineManager : public classbase
{
protected:
- /** The owner/creator of this class
- */
- InspIRCd* ServerInstance;
-
/** Used to hold XLines which have not yet been applied.
*/
std::vector<XLine *> pending_lines;
/** Constructor
* @param Instance A pointer to the creator object
*/
- XLineManager(InspIRCd* Instance);
+ XLineManager();
/** Destructor
*/
class CoreExport GLineFactory : public XLineFactory
{
public:
- GLineFactory(InspIRCd* Instance) : XLineFactory(Instance, "G") { }
+ GLineFactory() : XLineFactory("G") { }
/** Generate a GLine
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
IdentHostPair ih = ServerInstance->XLines->IdentSplit(xline_specific_mask);
- return new GLine(ServerInstance, set_time, duration, source, reason, ih.first, ih.second);
+ return new GLine(set_time, duration, source, reason, ih.first, ih.second);
}
};
class CoreExport ELineFactory : public XLineFactory
{
public:
- ELineFactory(InspIRCd* Instance) : XLineFactory(Instance, "E") { }
+ ELineFactory() : XLineFactory("E") { }
/** Generate an ELine
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
IdentHostPair ih = ServerInstance->XLines->IdentSplit(xline_specific_mask);
- return new ELine(ServerInstance, set_time, duration, source, reason, ih.first, ih.second);
+ return new ELine(set_time, duration, source, reason, ih.first, ih.second);
}
};
class CoreExport KLineFactory : public XLineFactory
{
public:
- KLineFactory(InspIRCd* Instance) : XLineFactory(Instance, "K") { }
+ KLineFactory() : XLineFactory("K") { }
/** Generate a KLine
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
IdentHostPair ih = ServerInstance->XLines->IdentSplit(xline_specific_mask);
- return new KLine(ServerInstance, set_time, duration, source, reason, ih.first, ih.second);
+ return new KLine(set_time, duration, source, reason, ih.first, ih.second);
}
};
class CoreExport QLineFactory : public XLineFactory
{
public:
- QLineFactory(InspIRCd* Instance) : XLineFactory(Instance, "Q") { }
+ QLineFactory() : XLineFactory("Q") { }
/** Generate a QLine
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
- return new QLine(ServerInstance, set_time, duration, source, reason, xline_specific_mask);
+ return new QLine(set_time, duration, source, reason, xline_specific_mask);
}
};
class CoreExport ZLineFactory : public XLineFactory
{
public:
- ZLineFactory(InspIRCd* Instance) : XLineFactory(Instance, "Z") { }
+ ZLineFactory() : XLineFactory("Z") { }
/** Generate a ZLine
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
- return new ZLine(ServerInstance, set_time, duration, source, reason, xline_specific_mask);
+ return new ZLine(set_time, duration, source, reason, xline_specific_mask);
}
};
if (this->BanHash->find(ip) != this->BanHash->end()) // can't have two cache entries on the same IP, sorry..
return NULL;
- b = new BanCacheHit(ServerInstance, ip, type, reason);
+ b = new BanCacheHit(ip, type, reason);
this->BanHash->insert(std::make_pair(ip, b));
return b;
if (this->BanHash->find(ip) != this->BanHash->end()) // can't have two cache entries on the same IP, sorry..
return NULL;
- b = new BanCacheHit(ServerInstance, ip, type, reason, seconds);
+ b = new BanCacheHit(ip, type, reason, seconds);
this->BanHash->insert(std::make_pair(ip, b));
return b;
#include <cstdarg>
#include "mode.h"
-Channel::Channel(InspIRCd* Instance, const std::string &cname, time_t ts)
+Channel::Channel(const std::string &cname, time_t ts)
{
chan_hash::iterator findchan = ServerInstance->chanlist->find(cname);
- if (findchan != Instance->chanlist->end())
+ if (findchan != ServerInstance->chanlist->end())
throw CoreException("Cannot create duplicate channel " + cname);
(*(ServerInstance->chanlist))[cname.c_str()] = this;
ModResult res;
/* 0: check status, 1: don't, -1: disallow change silently */
- FIRST_MOD_RESULT(ServerInstance, OnPreTopicChange, res, (u,this,ntopic));
+ FIRST_MOD_RESULT(OnPreTopicChange, res, (u,this,ntopic));
if (res == MOD_RES_DENY)
return CMD_FAILURE;
* add a channel to a user, creating the record for it if needed and linking
* it to the user record
*/
-Channel* Channel::JoinUser(InspIRCd* Instance, User *user, const char* cn, bool override, const char* key, bool bursting, time_t TS)
+Channel* Channel::JoinUser(User *user, const char* cn, bool override, const char* key, bool bursting, time_t TS)
{
// Fix: unregistered users could be joined using /SAJOIN
if (!user || !cn || user->registered != REG_ALL)
{
if (user->HasPrivPermission("channels/high-join-limit"))
{
- if (user->chans.size() >= Instance->Config->OperMaxChans)
+ if (user->chans.size() >= ServerInstance->Config->OperMaxChans)
{
user->WriteNumeric(ERR_TOOMANYCHANNELS, "%s %s :You are on too many channels",user->nick.c_str(), cn);
return NULL;
}
}
- strlcpy(cname, cn, Instance->Config->Limits.ChanMax);
- Ptr = Instance->FindChan(cname);
+ strlcpy(cname, cn, ServerInstance->Config->Limits.ChanMax);
+ Ptr = ServerInstance->FindChan(cname);
bool created_by_local = false;
if (!Ptr)
if (!IS_LOCAL(user))
{
if (!TS)
- Instance->Logs->Log("CHANNEL",DEBUG,"*** BUG *** Channel::JoinUser called for REMOTE user '%s' on channel '%s' but no TS given!", user->nick.c_str(), cn);
+ ServerInstance->Logs->Log("CHANNEL",DEBUG,"*** BUG *** Channel::JoinUser called for REMOTE user '%s' on channel '%s' but no TS given!", user->nick.c_str(), cn);
}
else
{
if (IS_LOCAL(user) && override == false)
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(Instance, OnUserPreJoin, MOD_RESULT, (user, NULL, cname, privs, key ? key : ""));
+ FIRST_MOD_RESULT(OnUserPreJoin, MOD_RESULT, (user, NULL, cname, privs, key ? key : ""));
if (MOD_RESULT == MOD_RES_DENY)
return NULL;
}
- Ptr = new Channel(Instance, cname, TS);
+ Ptr = new Channel(cname, TS);
}
else
{
if (IS_LOCAL(user) && override == false)
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(Instance, OnUserPreJoin, MOD_RESULT, (user, Ptr, cname, privs, key ? key : ""));
+ FIRST_MOD_RESULT(OnUserPreJoin, MOD_RESULT, (user, Ptr, cname, privs, key ? key : ""));
if (MOD_RESULT == MOD_RES_DENY)
{
return NULL;
{
std::string ckey = Ptr->GetModeParameter('k');
bool invited = user->IsInvited(Ptr->name.c_str());
- bool can_bypass = Instance->Config->InvBypassModes && invited;
+ bool can_bypass = ServerInstance->Config->InvBypassModes && invited;
if (!ckey.empty())
{
- FIRST_MOD_RESULT(Instance, OnCheckKey, MOD_RESULT, (user, Ptr, key ? key : ""));
+ FIRST_MOD_RESULT(OnCheckKey, MOD_RESULT, (user, Ptr, key ? key : ""));
if (!MOD_RESULT.check((key && ckey == key) || can_bypass))
{
// If no key provided, or key is not the right one, and can't bypass +k (not invited or option not enabled)
if (Ptr->IsModeSet('i'))
{
- FIRST_MOD_RESULT(Instance, OnCheckInvite, MOD_RESULT, (user, Ptr));
+ FIRST_MOD_RESULT(OnCheckInvite, MOD_RESULT, (user, Ptr));
if (!MOD_RESULT.check(invited))
{
user->WriteNumeric(ERR_INVITEONLYCHAN, "%s %s :Cannot join channel (Invite only)",user->nick.c_str(), Ptr->name.c_str());
std::string limit = Ptr->GetModeParameter('l');
if (!limit.empty())
{
- FIRST_MOD_RESULT(Instance, OnCheckLimit, MOD_RESULT, (user, Ptr));
+ FIRST_MOD_RESULT(OnCheckLimit, MOD_RESULT, (user, Ptr));
if (!MOD_RESULT.check((Ptr->GetUserCounter() < atol(limit.c_str()) || can_bypass)))
{
user->WriteNumeric(ERR_CHANNELISFULL, "%s %s :Cannot join channel (Channel is full)",user->nick.c_str(), Ptr->name.c_str());
Ptr->SetDefaultModes();
}
- return Channel::ForceChan(Instance, Ptr, user, privs, bursting, created_by_local);
+ return Channel::ForceChan(Ptr, user, privs, bursting, created_by_local);
}
-Channel* Channel::ForceChan(InspIRCd* Instance, Channel* Ptr, User* user, const std::string &privs, bool bursting, bool created)
+Channel* Channel::ForceChan(Channel* Ptr, User* user, const std::string &privs, bool bursting, bool created)
{
std::string nick = user->nick;
for (std::string::const_iterator x = privs.begin(); x != privs.end(); x++)
{
const char status = *x;
- ModeHandler* mh = Instance->Modes->FindMode(status, MODETYPE_CHANNEL);
+ ModeHandler* mh = ServerInstance->Modes->FindMode(status, MODETYPE_CHANNEL);
if (mh)
{
/* Set, and make sure that the mode handler knows this mode was now set */
Ptr->SetPrefix(user, mh->GetModeChar(), true);
- mh->OnModeChange(Instance->FakeClient, Instance->FakeClient, Ptr, nick, true);
+ mh->OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, Ptr, nick, true);
}
}
CUList except_list;
- FOREACH_MOD_I(Instance,I_OnUserJoin,OnUserJoin(memb, bursting, created, except_list));
+ FOREACH_MOD(I_OnUserJoin,OnUserJoin(memb, bursting, created, except_list));
Ptr->WriteAllExcept(user, false, 0, except_list, "JOIN :%s", Ptr->name.c_str());
/* Theyre not the first ones in here, make sure everyone else sees the modes we gave the user */
- std::string ms = Instance->Modes->ModeString(user, Ptr);
+ std::string ms = ServerInstance->Modes->ModeString(user, Ptr);
if ((Ptr->GetUserCounter() > 1) && (ms.length()))
Ptr->WriteAllExceptSender(user, true, 0, "MODE %s +%s", Ptr->name.c_str(), ms.c_str());
}
Ptr->UserList(user);
}
- FOREACH_MOD_I(Instance,I_OnPostJoin,OnPostJoin(memb));
+ FOREACH_MOD(I_OnPostJoin,OnPostJoin(memb));
return Ptr;
}
bool Channel::IsBanned(User* user)
{
ModResult result;
- FIRST_MOD_RESULT(ServerInstance, OnCheckChannelBan, result, (user, this));
+ FIRST_MOD_RESULT(OnCheckChannelBan, result, (user, this));
if (result != MOD_RES_PASSTHRU)
return (result == MOD_RES_DENY);
bool Channel::CheckBan(User* user, const std::string& mask)
{
ModResult result;
- FIRST_MOD_RESULT(ServerInstance, OnCheckBan, result, (user, this, mask));
+ FIRST_MOD_RESULT(OnCheckBan, result, (user, this, mask));
if (result != MOD_RES_PASSTHRU)
return (result == MOD_RES_DENY);
ModResult Channel::GetExtBanStatus(User *user, char type)
{
ModResult rv;
- FIRST_MOD_RESULT(ServerInstance, OnExtBanCheck, rv, (user, this, type));
+ FIRST_MOD_RESULT(OnExtBanCheck, rv, (user, this, type));
if (rv != MOD_RES_PASSTHRU)
return rv;
for (BanList::iterator i = this->bans.begin(); i != this->bans.end(); i++)
if (iter != ServerInstance->chanlist->end())
{
ModResult res;
- FIRST_MOD_RESULT(ServerInstance, OnChannelPreDelete, res, (this));
+ FIRST_MOD_RESULT(OnChannelPreDelete, res, (this));
if (res == MOD_RES_DENY)
return 1; // delete halted by module
FOREACH_MOD(I_OnChannelDelete, OnChannelDelete(this));
if (ServerInstance->ULine(src->server))
res = MOD_RES_ALLOW;
else
- FIRST_MOD_RESULT(ServerInstance, OnUserPreKick, res, (src,memb,reason));
+ FIRST_MOD_RESULT(OnUserPreKick, res, (src,memb,reason));
if (res == MOD_RES_DENY)
return this->GetUserCounter();
if (iter != ServerInstance->chanlist->end())
{
ModResult res;
- FIRST_MOD_RESULT(ServerInstance, OnChannelPreDelete, res, (this));
+ FIRST_MOD_RESULT(OnChannelPreDelete, res, (this));
if (res == MOD_RES_DENY)
return 1; // delete halted by module
FOREACH_MOD(I_OnChannelDelete, OnChannelDelete(this));
if (!IS_LOCAL(user))
return;
- FIRST_MOD_RESULT(ServerInstance, OnUserList, call_modules, (user, this));
+ FIRST_MOD_RESULT(OnUserList, call_modules, (user, this));
if (call_modules != MOD_RES_ALLOW)
{
int InspIRCd::PassCompare(Extensible* ex, const std::string &data, const std::string &input, const std::string &hashtype)
{
ModResult res;
- FIRST_MOD_RESULT(this, OnPassCompare, res, (ex, data, input, hashtype));
+ FIRST_MOD_RESULT(OnPassCompare, res, (ex, data, input, hashtype));
/* Module matched */
if (res == MOD_RES_ALLOW)
if (cm == cmdlist.end())
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnPreCommand, MOD_RESULT, (command, command_p, user, false, cmd));
+ FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, false, cmd));
if (MOD_RESULT == MOD_RES_DENY)
return true;
* truncate to max_params if necessary. -- w00t
*/
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnPreCommand, MOD_RESULT, (command, command_p, user, false, cmd));
+ FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, false, cmd));
if (MOD_RESULT == MOD_RES_DENY)
return true;
cm->second->total_bytes += cmd.length();
/* module calls too */
- FIRST_MOD_RESULT(ServerInstance, OnPreCommand, MOD_RESULT, (command, command_p, user, true, cmd));
+ FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, true, cmd));
if (MOD_RESULT == MOD_RES_DENY)
return do_more;
return false;
}
-CommandParser::CommandParser(InspIRCd* Instance) : ServerInstance(Instance)
+CommandParser::CommandParser()
{
para.resize(128);
}
if ((parameters.size()) && (!parameters[0].empty()))
{
- FIRST_MOD_RESULT(ServerInstance, OnSetAway, MOD_RESULT, (user, parameters[0]));
+ FIRST_MOD_RESULT(OnSetAway, MOD_RESULT, (user, parameters[0]));
if (MOD_RESULT == MOD_RES_DENY && IS_LOCAL(user))
return CMD_FAILURE;
}
else
{
- FIRST_MOD_RESULT(ServerInstance, OnSetAway, MOD_RESULT, (user, ""));
+ FIRST_MOD_RESULT(OnSetAway, MOD_RESULT, (user, ""));
if (MOD_RESULT == MOD_RES_DENY && IS_LOCAL(user))
return CMD_FAILURE;
long duration = ServerInstance->Duration(parameters[1].c_str());
- ELine* el = new ELine(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ih.first.c_str(), ih.second.c_str());
+ ELine* el = new ELine(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ih.first.c_str(), ih.second.c_str());
if (ServerInstance->XLines->AddLine(el, user))
{
if (!duration)
}
long duration = ServerInstance->Duration(parameters[1].c_str());
- GLine* gl = new GLine(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ih.first.c_str(), ih.second.c_str());
+ GLine* gl = new GLine(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ih.first.c_str(), ih.second.c_str());
if (ServerInstance->XLines->AddLine(gl, user))
{
if (!duration)
return CMD_FAILURE;
}
- FIRST_MOD_RESULT(ServerInstance, OnUserPreInvite, MOD_RESULT, (user,u,c,timeout));
+ FIRST_MOD_RESULT(OnUserPreInvite, MOD_RESULT, (user,u,c,timeout));
if (MOD_RESULT == MOD_RES_DENY)
{
if (ServerInstance->IsChannel(parameters[0].c_str(), ServerInstance->Config->Limits.ChanMax))
{
- Channel::JoinUser(ServerInstance, user, parameters[0].c_str(), false, parameters[1].c_str(), false);
+ Channel::JoinUser(user, parameters[0].c_str(), false, parameters[1].c_str(), false);
return CMD_SUCCESS;
}
}
if (ServerInstance->IsChannel(parameters[0].c_str(), ServerInstance->Config->Limits.ChanMax))
{
- Channel::JoinUser(ServerInstance, user, parameters[0].c_str(), false, "", false);
+ Channel::JoinUser(user, parameters[0].c_str(), false, "", false);
return CMD_SUCCESS;
}
}
* Moved this event inside the IS_LOCAL check also, we don't want half the network killing a user
* and the other half not. This would be a bad thing. ;p -- w00t
*/
- FIRST_MOD_RESULT(ServerInstance, OnKill, MOD_RESULT, (user, u, parameters[1]));
+ FIRST_MOD_RESULT(OnKill, MOD_RESULT, (user, u, parameters[1]));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
}
long duration = ServerInstance->Duration(parameters[1].c_str());
- KLine* kl = new KLine(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ih.first.c_str(), ih.second.c_str());
+ KLine* kl = new KLine(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ih.first.c_str(), ih.second.c_str());
if (ServerInstance->XLines->AddLine(kl,user))
{
if (!duration)
*/
oldnick.assign(user->nick, 0, IS_LOCAL(user) ? ServerInstance->Config->Limits.NickMax : MAXBUF);
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnUserPreNick, MOD_RESULT, (user,parameters[0]));
+ FIRST_MOD_RESULT(OnUserPreNick, MOD_RESULT, (user,parameters[0]));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
if (user->registered == REG_ALL)
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnUserPreNick, MOD_RESULT, (user, parameters[0]));
+ FIRST_MOD_RESULT(OnUserPreNick, MOD_RESULT, (user, parameters[0]));
if (MOD_RESULT == MOD_RES_DENY)
// if a module returns true, the nick change is silently forbidden.
return CMD_FAILURE;
if (user->registered == REG_NICKUSER)
{
/* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
- FIRST_MOD_RESULT(ServerInstance, OnUserRegister, MOD_RESULT, (user));
+ FIRST_MOD_RESULT(OnUserRegister, MOD_RESULT, (user));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
ModResult MOD_RESULT;
std::string temp = parameters[1];
- FIRST_MOD_RESULT(ServerInstance, OnUserPreNotice, MOD_RESULT, (user, (void*)parameters[0].c_str(), TYPE_SERVER, temp, 0, exempt_list));
+ FIRST_MOD_RESULT(OnUserPreNotice, MOD_RESULT, (user, (void*)parameters[0].c_str(), TYPE_SERVER, temp, 0, exempt_list));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
const char* text = temp.c_str();
ModResult MOD_RESULT;
std::string temp = parameters[1];
- FIRST_MOD_RESULT(ServerInstance, OnUserPreNotice, MOD_RESULT, (user,chan,TYPE_CHANNEL,temp,status, exempt_list));
+ FIRST_MOD_RESULT(OnUserPreNotice, MOD_RESULT, (user,chan,TYPE_CHANNEL,temp,status, exempt_list));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
ModResult MOD_RESULT;
std::string temp = parameters[1];
- FIRST_MOD_RESULT(ServerInstance, OnUserPreNotice, MOD_RESULT, (user,dest,TYPE_USER,temp,0,exempt_list));
+ FIRST_MOD_RESULT(OnUserPreNotice, MOD_RESULT, (user,dest,TYPE_USER,temp,0,exempt_list));
if (MOD_RESULT == MOD_RES_DENY) {
return CMD_FAILURE;
}
ModResult MOD_RESULT;
std::string temp = parameters[1];
- FIRST_MOD_RESULT(ServerInstance, OnUserPreMessage, MOD_RESULT, (user, (void*)parameters[0].c_str(), TYPE_SERVER, temp, 0, except_list));
+ FIRST_MOD_RESULT(OnUserPreMessage, MOD_RESULT, (user, (void*)parameters[0].c_str(), TYPE_SERVER, temp, 0, except_list));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
ModResult MOD_RESULT;
std::string temp = parameters[1];
- FIRST_MOD_RESULT(ServerInstance, OnUserPreMessage, MOD_RESULT, (user,chan,TYPE_CHANNEL,temp,status,except_list));
+ FIRST_MOD_RESULT(OnUserPreMessage, MOD_RESULT, (user,chan,TYPE_CHANNEL,temp,status,except_list));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
ModResult MOD_RESULT;
std::string temp = parameters[1];
- FIRST_MOD_RESULT(ServerInstance, OnUserPreMessage, MOD_RESULT, (user, dest, TYPE_USER, temp, 0, except_list));
+ FIRST_MOD_RESULT(OnUserPreMessage, MOD_RESULT, (user, dest, TYPE_USER, temp, 0, except_list));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
}
long duration = ServerInstance->Duration(parameters[1].c_str());
- QLine* ql = new QLine(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str());
+ QLine* ql = new QLine(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str());
if (ServerInstance->XLines->AddLine(ql,user))
{
if (!duration)
FOREACH_MOD(I_OnGarbageCollect, OnGarbageCollect());
- ServerInstance->ConfigThread = new ConfigReaderThread(ServerInstance, user->uuid);
+ ServerInstance->ConfigThread = new ConfigReaderThread(user->uuid);
ServerInstance->Threads->Start(ServerInstance->ConfigThread);
return CMD_SUCCESS;
ModResult MOD_RESULT;
/* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */
- FIRST_MOD_RESULT(ServerInstance, OnUserRegister, MOD_RESULT, (user));
+ FIRST_MOD_RESULT(OnUserRegister, MOD_RESULT, (user));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
{
syntax = "<nick>{,<nick>}";
Penalty = 2;
- timer = new WhoWasMaintainTimer(ServerInstance, 3600);
+ timer = new WhoWasMaintainTimer(3600);
ServerInstance->Timers->AddTimer(timer);
}
{
CommandWhowas cmd;
public:
- ModuleWhoWas(InspIRCd *Me) : Module(Me), cmd(this)
+ ModuleWhoWas() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
long duration = ServerInstance->Duration(parameters[1].c_str());
- ZLine* zl = new ZLine(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ipaddr);
+ ZLine* zl = new ZLine(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), ipaddr);
if (ServerInstance->XLines->AddLine(zl,user))
{
if (!duration)
#include "commands/cmd_whowas.h"
#include "modes/cmode_h.h"
-ServerConfig::ServerConfig(InspIRCd* Instance) : ServerInstance(Instance)
+ServerConfig::ServerConfig()
{
*sid = *ServerName = *Network = *ServerDesc = *AdminName = '\0';
*HideWhoisServer = *AdminEmail = *AdminNick = *diepass = *restartpass = *FixedQuit = *HideKillsServer = '\0';
dns_timeout = DieDelay = 5;
MaxTargets = 20;
NetBufferSize = 10240;
- SoftLimit = Instance->SE->GetMaxFds();
+ SoftLimit = ServerInstance->SE->GetMaxFds();
MaxConn = SOMAXCONN;
MaxWhoResults = 0;
debugging = 0;
{
if ((data.GetInteger() < 1) || (data.GetInteger() > 31))
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"WARNING: <security:maxtargets> value is greater than 31 or less than 1, set to 20.");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"WARNING: <security:maxtargets> value is greater than 31 or less than 1, set to 20.");
data.Set(20);
}
return true;
static bool ValidateSoftLimit(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
- if ((data.GetInteger() < 1) || (data.GetInteger() > conf->GetInstance()->SE->GetMaxFds()))
+ if ((data.GetInteger() < 1) || (data.GetInteger() > ServerInstance->SE->GetMaxFds()))
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"WARNING: <performance:softlimit> value is greater than %d or less than 0, set to %d.",conf->GetInstance()->SE->GetMaxFds(),conf->GetInstance()->SE->GetMaxFds());
- data.Set(conf->GetInstance()->SE->GetMaxFds());
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"WARNING: <performance:softlimit> value is greater than %d or less than 0, set to %d.",ServerInstance->SE->GetMaxFds(),ServerInstance->SE->GetMaxFds());
+ data.Set(ServerInstance->SE->GetMaxFds());
}
return true;
}
static bool ValidateMaxConn(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
if (data.GetInteger() > SOMAXCONN)
-
conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"WARNING: <performance:somaxconn> value may be higher than the system-defined SOMAXCONN value!");
+
ServerInstance->Logs->Log("CONFIG",DEFAULT,"WARNING: <performance:somaxconn> value may be higher than the system-defined SOMAXCONN value!");
return true;
}
{
std::string nameserver;
// attempt to look up their nameserver from /etc/resolv.conf
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"WARNING: <dns:server> not defined, attempting to find working server in /etc/resolv.conf...");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"WARNING: <dns:server> not defined, attempting to find working server in /etc/resolv.conf...");
std::ifstream resolv("/etc/resolv.conf");
bool found_server = false;
resolv >> nameserver;
data.Set(nameserver.c_str());
found_server = true;
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"<dns:server> set to '%s' as first resolver in /etc/resolv.conf.",nameserver.c_str());
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"<dns:server> set to '%s' as first resolver in /etc/resolv.conf.",nameserver.c_str());
}
}
if (!found_server)
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"/etc/resolv.conf contains no viable nameserver entries! Defaulting to nameserver '127.0.0.1'!");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"/etc/resolv.conf contains no viable nameserver entries! Defaulting to nameserver '127.0.0.1'!");
data.Set("127.0.0.1");
}
}
else
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"/etc/resolv.conf can't be opened! Defaulting to nameserver '127.0.0.1'!");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"/etc/resolv.conf can't be opened! Defaulting to nameserver '127.0.0.1'!");
data.Set("127.0.0.1");
}
}
static bool ValidateServerName(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"Validating server name");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"Validating server name");
/* If we already have a servername, and they changed it, we should throw an exception. */
if (!strchr(data.GetString(), '.'))
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"WARNING: <server:name> '%s' is not a fully-qualified domain name. Changed to '%s.'",
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"WARNING: <server:name> '%s' is not a fully-qualified domain name. Changed to '%s.'",
data.GetString(),data.GetString());
std::string moo = data.GetValue();
data.Set(moo.append("."));
// 65534 not 65535 because of null terminator
if ((!data.GetInteger()) || (data.GetInteger() > 65534) || (data.GetInteger() < 1024))
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
data.Set(10240);
}
return true;
{
if ((data.GetInteger() > 65535) || (data.GetInteger() < 1))
{
-
conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"<performance:maxwho> size out of range, setting to default of 128.");
+
ServerInstance->Logs->Log("CONFIG",DEFAULT,"<performance:maxwho> size out of range, setting to default of 128.");
data.Set(128);
}
return true;
static bool ValidateHalfOp(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
- ModeHandler* mh = conf->GetInstance()->Modes->FindMode('h', MODETYPE_CHANNEL);
+ ModeHandler* mh = ServerInstance->Modes->FindMode('h', MODETYPE_CHANNEL);
if (data.GetBool() && !mh) {
- conf->GetInstance()->Logs->Log("CONFIG", DEFAULT, "Enabling halfop mode.");
- mh = new ModeChannelHalfOp(conf->GetInstance());
- conf->GetInstance()->Modes->AddMode(mh);
+ ServerInstance->Logs->Log("CONFIG", DEFAULT, "Enabling halfop mode.");
+ mh = new ModeChannelHalfOp;
+ ServerInstance->Modes->AddMode(mh);
} else if (!data.GetBool() && mh) {
- conf->GetInstance()->Logs->Log("CONFIG", DEFAULT, "Disabling halfop mode.");
- conf->GetInstance()->Modes->DelMode(mh);
+ ServerInstance->Logs->Log("CONFIG", DEFAULT, "Disabling halfop mode.");
+ ServerInstance->Modes->DelMode(mh);
delete mh;
}
return true;
static bool ValidateSID(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"Validating server id");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"Validating server id");
const char *sid = data.GetString();
- if (*sid && !conf->GetInstance()->IsSID(sid))
+ if (*sid && !ServerInstance->IsSID(sid))
{
throw CoreException(std::string(sid) + " is not a valid server ID. A server ID must be 3 characters long, with the first character a digit and the next two characters a digit or letter.");
}
static bool ValidateWhoWas(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
- conf->WhoWasMaxKeep = conf->GetInstance()->Duration(data.GetString());
+ conf->WhoWasMaxKeep = ServerInstance->Duration(data.GetString());
if (conf->WhoWasGroupSize < 0)
conf->WhoWasGroupSize = 0;
if (conf->WhoWasMaxKeep < 3600)
{
conf->WhoWasMaxKeep = 3600;
- conf->GetInstance()->Logs->Log("CONFIG",DEFAULT,"WARNING: <whowas:maxkeep> value less than 3600, setting to default 3600");
+ ServerInstance->Logs->Log("CONFIG",DEFAULT,"WARNING: <whowas:maxkeep> value less than 3600, setting to default 3600");
}
- Module* whowas = conf->GetInstance()->Modules->Find("cmd_whowas.so");
+ Module* whowas = ServerInstance->Modules->Find("cmd_whowas.so");
if (whowas)
{
WhowasRequest(NULL, whowas, WhowasRequest::WHOWAS_PRUNE).Send();
const char* reason = values[0].GetString();
const char* ipmask = values[1].GetString();
- ZLine* zl = new ZLine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, ipmask);
- if (!conf->GetInstance()->XLines->AddLine(zl, NULL))
+ ZLine* zl = new ZLine(ServerInstance->Time(), 0, "<Config>", reason, ipmask);
+ if (!ServerInstance->XLines->AddLine(zl, NULL))
delete zl;
return true;
const char* reason = values[0].GetString();
const char* nick = values[1].GetString();
- QLine* ql = new QLine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, nick);
- if (!conf->GetInstance()->XLines->AddLine(ql, NULL))
+ QLine* ql = new QLine(ServerInstance->Time(), 0, "<Config>", reason, nick);
+ if (!ServerInstance->XLines->AddLine(ql, NULL))
delete ql;
return true;
const char* reason = values[0].GetString();
const char* host = values[1].GetString();
- XLineManager* xlm = conf->GetInstance()->XLines;
+ XLineManager* xlm = ServerInstance->XLines;
IdentHostPair ih = xlm->IdentSplit(host);
- KLine* kl = new KLine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, ih.first.c_str(), ih.second.c_str());
+ KLine* kl = new KLine(ServerInstance->Time(), 0, "<Config>", reason, ih.first.c_str(), ih.second.c_str());
if (!xlm->AddLine(kl, NULL))
delete kl;
return true;
const char* reason = values[0].GetString();
const char* host = values[1].GetString();
- XLineManager* xlm = conf->GetInstance()->XLines;
+ XLineManager* xlm = ServerInstance->XLines;
IdentHostPair ih = xlm->IdentSplit(host);
- ELine* el = new ELine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, ih.first.c_str(), ih.second.c_str());
+ ELine* el = new ELine(ServerInstance->Time(), 0, "<Config>", reason, ih.first.c_str(), ih.second.c_str());
if (!xlm->AddLine(el, NULL))
delete el;
return true;
return "/";
}
-InspIRCd* ServerConfig::GetInstance()
-{
- return ServerInstance;
-}
-
std::string ServerConfig::GetSID()
{
return sid;
void ConfigReaderThread::Run()
{
- Config = new ServerConfig(ServerInstance);
+ Config = new ServerConfig;
Config->Read();
done = true;
}
ServerInstance->ResetMaxBans();
Config->ApplyDisabledCommands(Config->DisabledCommands);
User* user = TheUserUID.empty() ? ServerInstance->FindNick(TheUserUID) : NULL;
- FOREACH_MOD_I(ServerInstance, I_OnRehash, OnRehash(user));
+ FOREACH_MOD(I_OnRehash, OnRehash(user));
ServerInstance->BuildISupport();
delete old;
DNS* dnsobj; /* DNS caller (where we get our FD from) */
unsigned long ttl; /* Time to live */
std::string orig; /* Original requested name/ip */
- InspIRCd* ServerInstance;
- DNSRequest(InspIRCd* Instance, DNS* dns, int id, const std::string &original);
+ DNSRequest(DNS* dns, int id, const std::string &original);
~DNSRequest();
DNSInfo ResultIsReady(DNSHeader &h, int length);
int SendRequests(const DNSHeader *header, const int length, QueryType qt);
class CacheTimer : public Timer
{
private:
- InspIRCd* ServerInstance;
DNS* dns;
public:
- CacheTimer(InspIRCd* Instance, DNS* thisdns)
- : Timer(3600, Instance->Time(), true), ServerInstance(Instance), dns(thisdns) { }
+ CacheTimer(DNS* thisdns)
+ : Timer(3600, ServerInstance->Time(), true), dns(thisdns) { }
virtual void Tick(time_t)
{
class RequestTimeout : public Timer
{
- InspIRCd* ServerInstance;
DNSRequest* watch;
int watchid;
public:
- RequestTimeout(unsigned long n, InspIRCd* SI, DNSRequest* watching, int id) : Timer(n, SI->Time()), ServerInstance(SI), watch(watching), watchid(id)
+ RequestTimeout(unsigned long n, DNSRequest* watching, int id) : Timer(n, ServerInstance->Time()), watch(watching), watchid(id)
{
}
~RequestTimeout()
};
/* Allocate the processing buffer */
-DNSRequest::DNSRequest(InspIRCd* Instance, DNS* dns, int rid, const std::string &original) : dnsobj(dns), ServerInstance(Instance)
+DNSRequest::DNSRequest(DNS* dns, int rid, const std::string &original) : dnsobj(dns)
{
res = new unsigned char[512];
*res = 0;
orig = original;
- RequestTimeout* RT = new RequestTimeout(Instance->Config->dns_timeout ? Instance->Config->dns_timeout : 5, Instance, this, rid);
- Instance->Timers->AddTimer(RT); /* The timer manager frees this */
+ RequestTimeout* RT = new RequestTimeout(ServerInstance->Config->dns_timeout ? ServerInstance->Config->dns_timeout : 5, this, rid);
+ ServerInstance->Timers->AddTimer(RT); /* The timer manager frees this */
}
/* Deallocate the processing buffer */
while (requests[id])
id = this->PRNG() & DNS::MAX_REQUEST_ID;
- DNSRequest* req = new DNSRequest(ServerInstance, this, id, original);
+ DNSRequest* req = new DNSRequest(this, id, original);
header->id[0] = req->id[0] = id >> 8;
header->id[1] = req->id[1] = id & 0xFF;
}
/** Initialise the DNS UDP socket so that we can send requests */
-DNS::DNS(InspIRCd* Instance) : ServerInstance(Instance)
+DNS::DNS()
{
ServerInstance->Logs->Log("RESOLVER",DEBUG,"DNS::DNS");
/* Clear the Resolver class table */
*/
this->Rehash();
- this->PruneTimer = new CacheTimer(ServerInstance, this);
+ this->PruneTimer = new CacheTimer(this);
ServerInstance->Timers->AddTimer(this->PruneTimer);
}
}
/** High level abstraction of dns used by application at large */
-Resolver::Resolver(InspIRCd* Instance, const std::string &source, QueryType qt, bool &cached, Module* creator) : ServerInstance(Instance), Creator(creator), input(source), querytype(qt)
+Resolver::Resolver(const std::string &source, QueryType qt, bool &cached, Module* creator) : Creator(creator), input(source), querytype(qt)
{
ServerInstance->Logs->Log("RESOLVER",DEBUG,"Resolver::Resolver");
cached = false;
#include <dlfcn.h>
#endif
-DLLManager::DLLManager(InspIRCd*, const char *fname)
+DLLManager::DLLManager(const char *fname)
{
err = NULL;
#include "inspircd_se_config.h"
#include "filelogger.h"
-FileLogStream::FileLogStream(InspIRCd *Instance, int loglevel, FileWriter *fw)
- : LogStream(Instance, loglevel), f(fw)
+FileLogStream::FileLogStream(int loglevel, FileWriter *fw)
+ : LogStream(loglevel), f(fw)
{
ServerInstance->Logs->AddLoggerRef(f);
}
}
-irc::modestacker::modestacker(InspIRCd* Instance, bool add) : ServerInstance(Instance), adding(add)
+irc::modestacker::modestacker(bool add) : adding(add)
{
sequence.clear();
sequence.push_back("");
{
std::string description;
- FOREACH_MOD_I(this,I_OnGetServerDescription,OnGetServerDescription(servername,description));
+ FOREACH_MOD(I_OnGetServerDescription,OnGetServerDescription(servername,description));
if (!description.empty())
{
return false;
}
- FileWriter* fw = new FileWriter(this, Config->log_file);
- FileLogStream *f = new FileLogStream(this, (Config->forcedebug ? DEBUG : DEFAULT), fw);
+ FileWriter* fw = new FileWriter(Config->log_file);
+ FileLogStream *f = new FileLogStream((Config->forcedebug ? DEBUG : DEFAULT), fw);
this->Logs->AddLogType("*", f, true);
std::string copy_text = text;
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(this, OnWhoisLine, MOD_RESULT, (user, dest, numeric, copy_text));
+ FIRST_MOD_RESULT(OnWhoisLine, MOD_RESULT, (user, dest, numeric, copy_text));
- if (!MOD_RESULT)
+ if (MOD_RESULT != MOD_RES_DENY)
user->WriteServ("%d %s", numeric, copy_text.c_str());
}
}
InspIRCd::InspIRCd(int argc, char** argv) :
- /* Functor initialisation. Note that the ordering here is very important.
- *
- * THIS MUST MATCH ORDER OF DECLARATION OF THE HandleWhateverFunc classes
- * within class InspIRCd.
- */
- HandleIsNick(this),
- HandleIsIdent(this),
- HandleFloodQuitUser(this),
- HandleIsChannel(this),
- HandleIsSID(this),
- HandleRehash(this),
ConfigFileName("inspircd.conf"),
- /* Functor pointer initialisation. Must match the order of the list above
+ /* Functor pointer initialisation.
*
* THIS MUST MATCH THE ORDER OF DECLARATION OF THE FUNCTORS, e.g. the methods
* themselves within the class.
this->TIME = time(NULL);
// This must be created first, so other parts of Insp can use it while starting up
- this->Logs = new LogManager(this);
+ this->Logs = new LogManager;
SocketEngineFactory SEF;
SE = SEF.Create();
- this->Threads = new ThreadEngine(this);
+ this->Threads = new ThreadEngine;
/* Default implementation does nothing */
- this->PI = new ProtocolInterface(this);
+ this->PI = new ProtocolInterface;
this->s_signal = 0;
// Create base manager classes early, so nothing breaks
- this->Users = new UserManager(this);
+ this->Users = new UserManager;
this->Users->unregistered_count = 0;
this->Users->uuidlist = new user_hash();
this->chanlist = new chan_hash();
- this->Config = new ServerConfig(this);
- this->SNO = new SnomaskManager(this);
- this->BanCache = new BanCacheManager(this);
+ this->Config = new ServerConfig;
+ this->SNO = new SnomaskManager;
+ this->BanCache = new BanCacheManager;
this->Modules = new ModuleManager();
this->stats = new serverstats();
- this->Timers = new TimerManager(this);
- this->Parser = new CommandParser(this);
- this->XLines = new XLineManager(this);
+ this->Timers = new TimerManager;
+ this->Parser = new CommandParser;
+ this->XLines = new XLineManager;
this->Config->argv = argv;
this->Config->argc = argc;
// Handle forking
if(!do_nofork)
{
- DWORD ExitCode = WindowsForkStart(this);
+ DWORD ExitCode = WindowsForkStart();
if(ExitCode)
exit(ExitCode);
}
// Set up winsock
WSADATA wsadata;
WSAStartup(MAKEWORD(2,0), &wsadata);
- ChangeWindowsSpecificPointers(this);
+ ChangeWindowsSpecificPointers();
#endif
Config->MyExecutable = argv[0];
printf_c("\t\033[1;32mpeavey, aquanight, psychon, dz, danieldg\033[0m\n\n");
printf_c("Others:\t\t\t\033[1;32mSee /INFO Output\033[0m\n");
- this->Modes = new ModeParser(this);
+ this->Modes = new ModeParser;
if (!do_root)
this->CheckRoot();
this->Config->Apply(NULL, "");
Logs->OpenFileLogs();
- this->Res = new DNS(this);
+ this->Res = new DNS;
this->AddServerName(Config->ServerName);
}
/* set up fake client again this time with the correct uid */
- this->FakeClient = new FakeUser(this, "!");
+ this->FakeClient = new FakeUser("!");
this->FakeClient->SetFakeServer(Config->ServerName);
// Get XLine to do it's thing.
}
}
#else
- WindowsIPC = new IPC(this);
+ WindowsIPC = new IPC;
if(!Config->nofork)
{
- WindowsForkKillOwner(this);
+ WindowsForkKillOwner();
FreeConsole();
}
/* Set win32 service as running, if we are running as a service */
/* See if we're supposed to be running the test suite rather than entering the mainloop */
if (Config->TestSuite)
{
- TestSuite* ts = new TestSuite(this);
+ TestSuite* ts = new TestSuite;
delete ts;
Exit(0);
}
if ((TIME % 3600) == 0)
{
this->RehashUsersAndChans();
- FOREACH_MOD_I(this, I_OnGarbageCollect, OnGarbageCollect());
+ FOREACH_MOD(I_OnGarbageCollect, OnGarbageCollect());
}
Timers->TickTimers(TIME);
if ((TIME % 5) == 0)
{
- FOREACH_MOD_I(this,I_OnBackgroundTimer,OnBackgroundTimer(TIME));
+ FOREACH_MOD(I_OnBackgroundTimer,OnBackgroundTimer(TIME));
SNO->FlushSnotices();
}
#ifndef WIN32
bool InspIRCd::AllModulesReportReady(User* user)
{
ModResult res;
- FIRST_MOD_RESULT(this, OnCheckReady, res, (user));
+ FIRST_MOD_RESULT(OnCheckReady, res, (user));
return (res == MOD_RES_PASSTHRU);
}
irc::sockets::sockaddrs ListenSocketBase::client;
irc::sockets::sockaddrs ListenSocketBase::server;
-ListenSocketBase::ListenSocketBase(InspIRCd* Instance, int port, const std::string &addr) : ServerInstance(Instance), desc("plaintext")
+ListenSocketBase::ListenSocketBase(int port, const std::string &addr) : desc("plaintext")
{
irc::sockets::sockaddrs bind_to;
if (this->fd > -1)
{
- int rv = Instance->SE->Bind(this->fd, &bind_to.sa, sizeof(bind_to));
+ int rv = ServerInstance->SE->Bind(this->fd, &bind_to.sa, sizeof(bind_to));
if (rv >= 0)
- rv = Instance->SE->Listen(this->fd, Instance->Config->MaxConn);
+ rv = ServerInstance->SE->Listen(this->fd, ServerInstance->Config->MaxConn);
if (rv < 0)
{
- Instance->SE->Shutdown(this, 2);
- Instance->SE->Close(this);
+ ServerInstance->SE->Shutdown(this, 2);
+ ServerInstance->SE->Close(this);
this->fd = -1;
}
else
{
- Instance->SE->NonBlocking(this->fd);
- Instance->SE->AddFd(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE);
+ ServerInstance->SE->NonBlocking(this->fd);
+ ServerInstance->SE->AddFd(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE);
}
}
}
void ClientListenSocket::OnAcceptReady(int nfd)
{
- ServerInstance->Users->AddUser(ServerInstance, nfd, this, &client, &server);
+ ServerInstance->Users->AddUser(nfd, this, &client, &server);
}
{
if (!noforkstream)
{
- FileWriter* fw = new FileWriter(ServerInstance, stdout);
- noforkstream = new FileLogStream(ServerInstance, ServerInstance->Config->forcedebug ? DEBUG : DEFAULT, fw);
+ FileWriter* fw = new FileWriter(stdout);
+ noforkstream = new FileLogStream(ServerInstance->Config->forcedebug ? DEBUG : DEFAULT, fw);
}
else
{
{
return;
}
- ConfigReader* Conf = new ConfigReader(ServerInstance);
+ ConfigReader* Conf = new ConfigReader;
std::map<std::string, FileWriter*> logmap;
std::map<std::string, FileWriter*>::iterator i;
for (int index = 0; index < Conf->Enumerate("log"); ++index)
if ((i = logmap.find(target)) == logmap.end())
{
FILE* f = fopen(target.c_str(), "a");
- fw = new FileWriter(ServerInstance, f);
+ fw = new FileWriter(f);
logmap.insert(std::make_pair(target, fw));
}
else
{
fw = i->second;
}
- FileLogStream* fls = new FileLogStream(ServerInstance, loglevel, fw);
+ FileLogStream* fls = new FileLogStream(loglevel, fw);
AddLogTypes(type, fls, true);
}
}
}
-FileWriter::FileWriter(InspIRCd* Instance, FILE* logfile)
-: ServerInstance(Instance), log(logfile), writeops(0)
+FileWriter::FileWriter(FILE* logfile)
+: log(logfile), writeops(0)
{
}
return MODEACTION_DENY;
}
-ModeWatcher::ModeWatcher(InspIRCd* Instance, char modeletter, ModeType type) : ServerInstance(Instance), mode(modeletter), m_type(type)
+ModeWatcher::ModeWatcher(char modeletter, ModeType type) : mode(modeletter), m_type(type)
{
}
int pcnt = mh->GetNumParams(adding);
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnRawMode, MOD_RESULT, (user, chan, modechar, parameter, adding, pcnt));
+ FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, modechar, parameter, adding, pcnt));
if (IS_LOCAL(user) && (MOD_RESULT == MOD_RES_DENY))
return MODEACTION_DENY;
else
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnPreMode, MOD_RESULT, (user, targetuser, targetchannel, parameters));
+ FIRST_MOD_RESULT(OnPreMode, MOD_RESULT, (user, targetuser, targetchannel, parameters));
if (MOD_RESULT == MOD_RES_DENY)
return;
SkipAccessChecks = (MOD_RESULT == MOD_RES_ALLOW);
return;
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnRawMode, MOD_RESULT, (user, chan, mletter, "", true, 0));
+ FIRST_MOD_RESULT(OnRawMode, MOD_RESULT, (user, chan, mletter, "", true, 0));
if (MOD_RESULT == MOD_RES_DENY)
continue;
}
}
-ModeParser::ModeParser(InspIRCd* Instance)
+ModeParser::ModeParser()
{
ModeHandler* modes[] =
{
- new ModeChannelSecret(Instance),
- new ModeChannelPrivate(Instance),
- new ModeChannelModerated(Instance),
- new ModeChannelTopicOps(Instance),
-
- new ModeChannelNoExternal(Instance),
- new ModeChannelInviteOnly(Instance),
- new ModeChannelKey(Instance),
- new ModeChannelLimit(Instance),
-
- new ModeChannelBan(Instance),
- new ModeChannelOp(Instance),
- new ModeChannelHalfOp(Instance),
- new ModeChannelVoice(Instance),
-
- new ModeUserWallops(Instance),
- new ModeUserInvisible(Instance),
- new ModeUserOperator(Instance),
- new ModeUserServerNoticeMask(Instance),
+ new ModeChannelSecret,
+ new ModeChannelPrivate,
+ new ModeChannelModerated,
+ new ModeChannelTopicOps,
+
+ new ModeChannelNoExternal,
+ new ModeChannelInviteOnly,
+ new ModeChannelKey,
+ new ModeChannelLimit,
+
+ new ModeChannelBan,
+ new ModeChannelOp,
+ new ModeChannelHalfOp,
+ new ModeChannelVoice,
+
+ new ModeUserWallops,
+ new ModeUserInvisible,
+ new ModeUserOperator,
+ new ModeUserServerNoticeMask,
#define BUILTIN_MODE_COUNT 16
};
#include "hashcomp.h"
#include "modes/cmode_b.h"
-ModeChannelBan::ModeChannelBan(InspIRCd* Instance) : ModeHandler(NULL, 'b', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelBan::ModeChannelBan() : ModeHandler(NULL, 'b', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
}
}
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnAddBan, MOD_RESULT, (user,chan,dest));
+ FIRST_MOD_RESULT(OnAddBan, MOD_RESULT, (user,chan,dest));
if (MOD_RESULT == MOD_RES_DENY)
{
dest = "";
if (!strcasecmp(i->data.c_str(), dest.c_str()))
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnDelBan, MOD_RESULT, (user, chan, dest));
+ FIRST_MOD_RESULT(OnDelBan, MOD_RESULT, (user, chan, dest));
if (MOD_RESULT == MOD_RES_DENY)
{
dest = "";
#include "modules.h"
#include "modes/cmode_h.h"
-ModeChannelHalfOp::ModeChannelHalfOp(InspIRCd* Instance) : ModeHandler(NULL, 'h', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelHalfOp::ModeChannelHalfOp() : ModeHandler(NULL, 'h', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = '%';
#include "users.h"
#include "modes/cmode_i.h"
-ModeChannelInviteOnly::ModeChannelInviteOnly(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'i')
+ModeChannelInviteOnly::ModeChannelInviteOnly() : SimpleChannelModeHandler(NULL, 'i')
{
}
#include "users.h"
#include "modes/cmode_k.h"
-ModeChannelKey::ModeChannelKey(InspIRCd* Instance) : ModeHandler(NULL, 'k', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelKey::ModeChannelKey() : ModeHandler(NULL, 'k', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
}
#include "users.h"
#include "modes/cmode_l.h"
-ModeChannelLimit::ModeChannelLimit(InspIRCd* Instance) : ModeHandler(NULL, 'l', PARAM_SETONLY, MODETYPE_CHANNEL)
+ModeChannelLimit::ModeChannelLimit() : ModeHandler(NULL, 'l', PARAM_SETONLY, MODETYPE_CHANNEL)
{
}
#include "users.h"
#include "modes/cmode_m.h"
-ModeChannelModerated::ModeChannelModerated(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'm')
+ModeChannelModerated::ModeChannelModerated() : SimpleChannelModeHandler(NULL, 'm')
{
}
#include "users.h"
#include "modes/cmode_n.h"
-ModeChannelNoExternal::ModeChannelNoExternal(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'n')
+ModeChannelNoExternal::ModeChannelNoExternal() : SimpleChannelModeHandler(NULL, 'n')
{
}
#include "modules.h"
#include "modes/cmode_o.h"
-ModeChannelOp::ModeChannelOp(InspIRCd* Instance) : ModeHandler(NULL, 'o', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelOp::ModeChannelOp() : ModeHandler(NULL, 'o', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = '@';
#include "users.h"
#include "modes/cmode_p.h"
-ModeChannelPrivate::ModeChannelPrivate(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'p')
+ModeChannelPrivate::ModeChannelPrivate() : SimpleChannelModeHandler(NULL, 'p')
{
}
#include "users.h"
#include "modes/cmode_s.h"
-ModeChannelSecret::ModeChannelSecret(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 's')
+ModeChannelSecret::ModeChannelSecret() : SimpleChannelModeHandler(NULL, 's')
{
}
#include "users.h"
#include "modes/cmode_t.h"
-ModeChannelTopicOps::ModeChannelTopicOps(InspIRCd* Instance) : ModeHandler(NULL, 't', PARAM_NONE, MODETYPE_CHANNEL)
+ModeChannelTopicOps::ModeChannelTopicOps() : ModeHandler(NULL, 't', PARAM_NONE, MODETYPE_CHANNEL)
{
}
#include "modules.h"
#include "modes/cmode_v.h"
-ModeChannelVoice::ModeChannelVoice(InspIRCd* Instance) : ModeHandler(NULL, 'v', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelVoice::ModeChannelVoice() : ModeHandler(NULL, 'v', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = '+';
#include "users.h"
#include "modes/umode_i.h"
-ModeUserInvisible::ModeUserInvisible(InspIRCd* Instance) : SimpleUserModeHandler(NULL, 'i')
+ModeUserInvisible::ModeUserInvisible() : SimpleUserModeHandler(NULL, 'i')
{
}
#include "users.h"
#include "modes/umode_o.h"
-ModeUserOperator::ModeUserOperator(InspIRCd* Instance) : ModeHandler(NULL, 'o', PARAM_NONE, MODETYPE_USER)
+ModeUserOperator::ModeUserOperator() : ModeHandler(NULL, 'o', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
#include "users.h"
#include "modes/umode_s.h"
-ModeUserServerNoticeMask::ModeUserServerNoticeMask(InspIRCd* Instance) : ModeHandler(NULL, 's', PARAM_SETONLY, MODETYPE_USER)
+ModeUserServerNoticeMask::ModeUserServerNoticeMask() : ModeHandler(NULL, 's', PARAM_SETONLY, MODETYPE_USER)
{
oper = true;
}
#include "users.h"
#include "modes/umode_w.h"
-ModeUserWallops::ModeUserWallops(InspIRCd* Instance) : SimpleUserModeHandler(NULL, 'w')
+ModeUserWallops::ModeUserWallops() : SimpleUserModeHandler(NULL, 'w')
{
}
return this->source;
}
-char* Event::Send(InspIRCd* SI)
+char* Event::Send()
{
FOREACH_MOD(I_OnEvent,OnEvent(this));
return NULL;
// These declarations define the behavours of the base class Module (which does nothing at all)
-Module::Module(InspIRCd*) { }
+Module::Module() { }
Module::~Module() { }
ModResult Module::OnSendSnotice(char &snomask, std::string &type, const std::string &message) { return MOD_RES_PASSTHRU; }
/* This will throw a CoreException if there's a problem loading
* the module file or getting a pointer to the init_module symbol.
*/
- newhandle = new ircd_module(ServerInstance, modfile, "init_module");
+ newhandle = new ircd_module(modfile, "init_module");
newmod = newhandle->CallInit();
if (newmod)
}
this->ModCount++;
- FOREACH_MOD_I(ServerInstance,I_OnLoadModule,OnLoadModule(newmod, filename_str));
+ FOREACH_MOD(I_OnLoadModule,OnLoadModule(newmod, filename_str));
/* We give every module a chance to re-prioritize when we introduce a new one,
* not just the one thats loading, as the new module could affect the preference
/* Tidy up any dangling resolvers */
ServerInstance->Res->CleanResolvers(modfind->second.second);
- FOREACH_MOD_I(ServerInstance,I_OnUnloadModule,OnUnloadModule(modfind->second.second, modfind->first));
+ FOREACH_MOD(I_OnUnloadModule,OnUnloadModule(modfind->second.second, modfind->first));
this->DetachAll(modfind->second.second);
return retval;
}
-ConfigReader::ConfigReader(InspIRCd* Instance)
+ConfigReader::ConfigReader()
{
this->error = 0;
}
return ServerInstance->Config->ConfVarEnum(tag, index);
}
-FileReader::FileReader(InspIRCd* Instance, const std::string &filename)
+FileReader::FileReader(const std::string &filename)
{
LoadFile(filename);
}
-FileReader::FileReader(InspIRCd* Instance)
+FileReader::FileReader()
{
}
public:
- ModuleGeoIP(InspIRCd *Me) : Module(Me)
- {
+ ModuleGeoIP() {
OnRehash(NULL);
Implementation eventlist[] = { I_OnRehash, I_OnUserRegister };
ServerInstance->Modules->Attach(eventlist, this, 2);
{
GeoBans.clear();
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
banunknown = conf.ReadFlag("geoip", "banunknown", 0);
LDAP *conn;
public:
- ModuleLDAPAuth(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleLDAPAuth()
+ {
conn = NULL;
Implementation eventlist[] = { I_OnUserDisconnect, I_OnCheckReady, I_OnRehash, I_OnUserRegister };
ServerInstance->Modules->Attach(eventlist, this, 4);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
base = Conf.ReadValue("ldapauth", "baserdn", 0);
attribute = Conf.ReadValue("ldapauth", "attribute", 0);
LDAP *conn;
public:
- ModuleLDAPAuth(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleLDAPAuth()
+ {
conn = NULL;
Implementation eventlist[] = { I_OnRehash, I_OnPassCompare };
ServerInstance->Modules->Attach(eventlist, this, 2);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
base = Conf.ReadValue("ldapoper", "baserdn", 0);
ldapserver = Conf.ReadValue("ldapoper", "server", 0);
{
private:
ModuleMsSQL* Parent;
- InspIRCd* ServerInstance;
public:
- QueryThread(InspIRCd* si, ModuleMsSQL* mod)
- : SocketThread(si), Parent(mod), ServerInstance(si)
- {
+ QueryThread(ModuleMsSQL* mod)
+ : SocketThread(si), Parent(mod), {
}
~QueryThread() { }
virtual void Run();
{
private:
ResultQueue results;
- InspIRCd* ServerInstance;
Module* mod;
SQLhost host;
TDSLOGIN* login;
public:
QueryQueue queue;
- SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)
- : ServerInstance(SI), mod(m), host(hi), login(NULL), sock(NULL), context(NULL)
+ SQLConn(Module* m, const SQLhost& hi)
+ : mod(m), host(hi), login(NULL), sock(NULL), context(NULL)
{
if (OpenDB())
{
QueryThread* queryDispatcher;
public:
- ModuleMsSQL(InspIRCd* Me)
- : Module(Me), currid(0)
+ ModuleMsSQL()
+ : currid(0)
{
LoggingMutex = new Mutex();
ResultsMutex = new Mutex();
ReadConf();
- queryDispatcher = new QueryThread(ServerInstance, this);
+ queryDispatcher = new QueryThread(this);
ServerInstance->Threads->Start(queryDispatcher);
ServerInstance->Modules->PublishInterface("SQL", this);
bool HostInConf(const SQLhost &h)
{
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
for(int i = 0; i < conf.Enumerate("database"); i++)
{
SQLhost host;
{
ClearOldConnections();
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
for(int i = 0; i < conf.Enumerate("database"); i++)
{
SQLhost host;
SQLConn* newconn;
- newconn = new SQLConn(ServerInstance, this, hi);
+ newconn = new SQLConn(this, hi);
connections.insert(std::make_pair(hi.id, newconn));
}
public:
ConfigReader *Conf;
- InspIRCd* PublicServerInstance;
int currid;
bool rehashing;
DispatcherThread* Dispatcher;
Mutex LoggingMutex;
Mutex ConnMutex;
- ModuleSQL(InspIRCd* Me);
+ ModuleSQL();
~ModuleSQL();
unsigned long NewID();
const char* OnRequest(Request* request);
}
}
-void ConnectDatabases(InspIRCd* ServerInstance, ModuleSQL* Parent)
+void ConnectDatabases(ModuleSQL* Parent)
{
for (ConnMap::iterator i = Connections.begin(); i != Connections.end(); i++)
{
}
}
-void LoadDatabases(ConfigReader* conf, InspIRCd* ServerInstance, ModuleSQL* Parent)
+void LoadDatabases(ConfigReader* conf, ModuleSQL* Parent)
{
Parent->ConnMutex.Lock();
ClearOldConnections(conf);
ThisSQL->setInitialQuery(initquery);
}
}
- ConnectDatabases(ServerInstance, Parent);
+ ConnectDatabases(Parent);
Parent->ConnMutex.Unlock();
}
{
private:
ModuleSQL* Parent;
- InspIRCd* ServerInstance;
public:
- DispatcherThread(InspIRCd* Instance, ModuleSQL* CreatorModule) : SocketThread(Instance), Parent(CreatorModule), ServerInstance(Instance) { }
+ DispatcherThread(ModuleSQL* CreatorModule) : SocketThread(Instance), Parent(CreatorModule),{ }
~DispatcherThread() { }
virtual void Run();
virtual void OnNotify();
};
-ModuleSQL::ModuleSQL(InspIRCd* Me) : Module(Me), rehashing(false)
+ModuleSQL::ModuleSQL() : rehashing(false)
{
ServerInstance->Modules->UseInterface("SQLutils");
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
PublicServerInstance = ServerInstance;
currid = 0;
- Dispatcher = new DispatcherThread(ServerInstance, this);
+ Dispatcher = new DispatcherThread(this);
ServerInstance->Threads->Start(Dispatcher);
if (!ServerInstance->Modules->PublishFeature("SQL", this))
private:
Module* mod;
public:
- ReconnectTimer(InspIRCd* SI, Module* m)
+ ReconnectTimer(Module* m)
: Timer(5, SI->Time(), false), mod(m)
{
}
class SQLConn : public EventHandler
{
private:
- InspIRCd* ServerInstance;
SQLhost confhost; /* The <database> entry */
Module* us; /* Pointer to the SQL provider itself */
PGconn* sql; /* PgSQL database connection handle */
time_t idle; /* Time we last heard from the database */
public:
- SQLConn(InspIRCd* SI, Module* self, const SQLhost& hi)
- : EventHandler(), ServerInstance(SI), confhost(hi), us(self), sql(NULL), status(CWRITE), qinprog(false)
+ SQLConn(Module* self, const SQLhost& hi)
+ : EventHandler(), confhost(hi), us(self), sql(NULL), status(CWRITE), qinprog(false)
{
idle = this->ServerInstance->Time();
if(!DoConnect())
ReconnectTimer* retimer;
public:
- ModulePgSQL(InspIRCd* Me)
- : Module(Me), currid(0)
+ ModulePgSQL()
+ : currid(0)
{
ServerInstance->Modules->UseInterface("SQLutils");
bool HostInConf(const SQLhost &h)
{
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
for(int i = 0; i < conf.Enumerate("database"); i++)
{
SQLhost host;
{
ClearOldConnections();
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
for(int i = 0; i < conf.Enumerate("database"); i++)
{
SQLhost host;
SQLConn* newconn;
- newconn = new SQLConn(ServerInstance, this, hi);
+ newconn = new SQLConn(this, hi);
connections.insert(std::make_pair(hi.id, newconn));
}
break;
}
}
- retimer = new ReconnectTimer(ServerInstance, this);
+ retimer = new ReconnectTimer(this);
ServerInstance->Timers->AddTimer(retimer);
}
pcre* regex;
public:
- PCRERegex(const std::string& rx, InspIRCd* Me) : Regex(rx, Me)
+ PCRERegex(const std::string& rx, ) : Regex(rx, Me)
{
const char* error;
int erroffset;
regex = pcre_compile(rx.c_str(), 0, &error, &erroffset, NULL);
if (!regex)
{
- Me->Logs->Log("REGEX", DEBUG, "pcre_compile failed: /%s/ [%d] %s", rx.c_str(), erroffset, error);
+ ServerInstance->Logs->Log("REGEX", DEBUG, "pcre_compile failed: /%s/ [%d] %s", rx.c_str(), erroffset, error);
throw PCREException(rx, error, erroffset);
}
}
class ModuleRegexPCRE : public Module
{
public:
- ModuleRegexPCRE(InspIRCd* Me) : Module(Me)
- {
- Me->Modules->PublishInterface("RegularExpression", this);
+ ModuleRegexPCRE() {
+ ServerInstance->Modules->PublishInterface("RegularExpression", this);
Implementation eventlist[] = { I_OnRequest };
- Me->Modules->Attach(eventlist, this, 1);
+ ServerInstance->Modules->Attach(eventlist, this, 1);
}
virtual Version GetVersion()
regex_t regbuf;
public:
- POSIXRegex(const std::string& rx, InspIRCd* Me, bool extended) : Regex(rx, Me)
+ POSIXRegex(const std::string& rx, bool extended) : Regex(rx, Me)
{
int flags = (extended ? REG_EXTENDED : 0) | REG_NOSUB;
int errcode;
private:
bool extended;
public:
- ModuleRegexPOSIX(InspIRCd* Me) : Module(Me)
- {
- Me->Modules->PublishInterface("RegularExpression", this);
+ ModuleRegexPOSIX() {
+ ServerInstance->Modules->PublishInterface("RegularExpression", this);
Implementation eventlist[] = { I_OnRequest, I_OnRehash };
- Me->Modules->Attach(eventlist, this, 2);
+ ServerInstance->Modules->Attach(eventlist, this, 2);
OnRehash(NULL);
}
virtual void OnRehash(User* u)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
extended = Conf.ReadFlag("posix", "extended", 0);
}
regex_t regbuf;
public:
- TRERegex(const std::string& rx, InspIRCd* Me) : Regex(rx, Me)
+ TRERegex(const std::string& rx, ) : Regex(rx, Me)
{
int flags = REG_EXTENDED | REG_NOSUB;
int errcode;
class ModuleRegexTRE : public Module
{
public:
- ModuleRegexTRE(InspIRCd* Me) : Module(Me)
- {
- Me->Modules->PublishInterface("RegularExpression", this);
+ ModuleRegexTRE() {
+ ServerInstance->Modules->PublishInterface("RegularExpression", this);
Implementation eventlist[] = { I_OnRequest };
- Me->Modules->Attach(eventlist, this, 1);
+ ServerInstance->Modules->Attach(eventlist, this, 1);
}
virtual Version GetVersion()
bool verbose;
public:
- ModuleSQLAuth(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleSQLAuth()
+ {
ServerInstance->Modules->UseInterface("SQLutils");
ServerInstance->Modules->UseInterface("SQL");
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
databaseid = Conf.ReadValue("sqlauth", "dbid", 0); /* Database ID, given to the SQL service provider */
freeformquery = Conf.ReadValue("sqlauth", "query", 0); /* Field name where username can be found */
ModuleSQLite3* mod;
public:
- ResultNotifier(ModuleSQLite3* m, InspIRCd* SI, int newfd, char* ip) : BufferedSocket(SI, newfd, ip), mod(m)
+ ResultNotifier(ModuleSQLite3* m, int newfd, char* ip) : BufferedSocket(SI, newfd, ip), mod(m)
{
}
FileReader* index;
public:
- SQLiteListener(ModuleSQLite3* P, InspIRCd* Instance, int port, const std::string &addr) : ListenSocketBase(Instance, port, addr), Parent(P)
+ SQLiteListener(ModuleSQLite3* P, int port, const std::string &addr) : ListenSocketBase(port, addr), Parent(P)
{
uslen = sizeof(sock_us);
if (getsockname(this->fd,(sockaddr*)&sock_us,&uslen))
{
private:
ResultQueue results;
- InspIRCd* ServerInstance;
Module* mod;
SQLhost host;
sqlite3* conn;
public:
- SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)
- : ServerInstance(SI), mod(m), host(hi)
+ SQLConn(Module* m, const SQLhost& hi)
+ : mod(m), host(hi)
{
if (OpenDB() != SQLITE_OK)
{
unsigned long currid;
public:
- ModuleSQLite3(InspIRCd* Me)
- : Module(Me), currid(0)
+ ModuleSQLite3()
+ : currid(0)
{
ServerInstance->Modules->UseInterface("SQLutils");
bool HostInConf(const SQLhost &h)
{
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
for(int i = 0; i < conf.Enumerate("database"); i++)
{
SQLhost host;
{
ClearOldConnections();
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
for(int i = 0; i < conf.Enumerate("database"); i++)
{
SQLhost host;
SQLConn* newconn;
- newconn = new SQLConn(ServerInstance, this, hi);
+ newconn = new SQLConn(this, hi);
connections.insert(std::make_pair(hi.id, newconn));
}
class QueryInfo
{
-private:
- InspIRCd* ServerInstance;
public:
QueryState qs;
unsigned long id;
time_t date;
bool insert;
- QueryInfo(InspIRCd* Instance, const std::string &n, const std::string &s, const std::string &h, unsigned long i, int cat)
+ QueryInfo(const std::string &n, const std::string &s, const std::string &h, unsigned long i, int cat)
{
ServerInstance = Instance;
qs = FIND_SOURCE;
{
public:
- ModuleSQLLog(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleSQLLog()
+ {
ServerInstance->Modules->UseInterface("SQLutils");
ServerInstance->Modules->UseInterface("SQL");
void ReadConfig()
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
dbid = Conf.ReadValue("sqllog","dbid",0); // database id of a database configured in sql module
}
SQLrequest req = SQLrequest(this, SQLModule, dbid, SQLquery("SELECT id,actor FROM ircd_log_actors WHERE actor='?'") % source);
if(req.Send())
{
- QueryInfo* i = new QueryInfo(ServerInstance, nick, source, host, req.id, category);
+ QueryInfo* i = new QueryInfo(nick, source, host, req.id, category);
i->qs = FIND_SOURCE;
active_queries[req.id] = i;
}
parameterlist names;
public:
- ModuleSQLOper(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleSQLOper()
+ {
ServerInstance->Modules->UseInterface("SQLutils");
ServerInstance->Modules->UseInterface("SQL");
ServerInstance->Modules->UseInterface("HashRequest");
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
databaseid = Conf.ReadValue("sqloper", "dbid", 0); /* Database ID of a database configured for the service provider module */
hashtype = assign(Conf.ReadValue("sqloper", "hash", 0));
bool OperUser(User* user, const std::string &pattern, const std::string &type)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
for (int j = 0; j < Conf.Enumerate("type"); j++)
{
IdChanMap idchan;
public:
- ModuleSQLutils(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleSQLutils()
+ {
ServerInstance->Modules->PublishInterface("SQLutils", this);
Implementation eventlist[] = { I_OnChannelDelete, I_OnUnloadModule, I_OnRequest, I_OnUserDisconnect };
ServerInstance->Modules->Attach(eventlist, this, 4);
GenericCap capHandler;
public:
- ModuleSSLGnuTLS(InspIRCd* Me)
- : Module(Me), starttls(this), capHandler(this, "tls")
+ ModuleSSLGnuTLS()
+ : starttls(this), capHandler(this, "tls")
{
ServerInstance->Modules->PublishInterface("BufferedSocketHook", this);
void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
listenports.clear();
sslports.clear();
OnRehash(user);
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
std::string confdir(ServerInstance->ConfigFileName);
// +1 so we the path ends with a /
public:
- ModuleSSLOpenSSL(InspIRCd* Me)
+ ModuleSSLOpenSSL()
{
ServerInstance->Modules->PublishInterface("BufferedSocketHook", this);
void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
listenports.clear();
sslports.clear();
OnRehash(user);
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
std::string confdir(ServerInstance->ConfigFileName);
// +1 so we the path ends with a /
public:
- ModuleTestClient(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleTestClient()
+ {
Implementation eventlist[] = { I_OnRequest, I_OnBackgroundTimer };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
unsigned int net_buffer_size;
public:
- ModuleZLib(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleZLib()
+ {
ServerInstance->Modules->PublishInterface("BufferedSocketHook", this);
sessions = new izip_session[ServerInstance->SE->GetMaxFds()];
public:
- ModuleAbbreviation(InspIRCd* Me)
- : Module(Me)
- {
- Me->Modules->Attach(I_OnPreCommand, this);
+ ModuleAbbreviation()
+ {
+ ServerInstance->Modules->Attach(I_OnPreCommand, this);
/* Must do this first */
- Me->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_FIRST);
+ ServerInstance->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_FIRST);
}
virtual Version GetVersion()
virtual void ReadAliases()
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
AllowBots = MyConf.ReadFlag("fantasy", "allowbots", "no", 0);
public:
- ModuleAlias(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleAlias()
+ {
ReadAliases();
- Me->Modules->Attach(I_OnPreCommand, this);
- Me->Modules->Attach(I_OnRehash, this);
- Me->Modules->Attach(I_OnUserMessage, this);
+ ServerInstance->Modules->Attach(I_OnPreCommand, this);
+ ServerInstance->Modules->Attach(I_OnRehash, this);
+ ServerInstance->Modules->Attach(I_OnUserMessage, this);
}
class AllowInvite : public SimpleChannelModeHandler
{
public:
- AllowInvite(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'A') { }
+ AllowInvite(Module* Creator) : SimpleChannelModeHandler(Creator, 'A') { }
};
class ModuleAllowInvite : public Module
AllowInvite ni;
public:
- ModuleAllowInvite(InspIRCd* Me) : Module(Me), ni(Me, this)
+ ModuleAllowInvite() : ni(this)
{
if (!ServerInstance->Modes->AddMode(&ni))
throw ModuleException("Could not add new modes!");
{
CommandAlltime mycommand;
public:
- Modulealltime(InspIRCd *Me)
- : Module(Me), mycommand(this)
+ Modulealltime()
+ : mycommand(this)
{
ServerInstance->AddCommand(&mycommand);
}
{
LocalIntExt bearExt;
public:
- ModuleAntiBear(InspIRCd* Me) : Module(Me), bearExt("antibear_timewait", this)
+ ModuleAntiBear() : bearExt("antibear_timewait", this)
{
Extensible::Register(&bearExt);
Implementation eventlist[] = { I_OnUserRegister, I_OnPreCommand };
{
if (!strncmp(parameters[1].c_str(), "\1TIME Mon May 01 18:54:20 2006", 30))
{
- ZLine* zl = new ZLine(ServerInstance, ServerInstance->Time(), 86400, ServerInstance->Config->ServerName,
+ ZLine* zl = new ZLine(ServerInstance->Time(), 86400, ServerInstance->Config->ServerName,
"Unless you're stuck in a time warp, you appear to be a bear bot!", user->GetIPString());
if (ServerInstance->XLines->AddLine(zl,NULL))
{
class ModuleAntiBottler : public Module
{
public:
- ModuleAntiBottler(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleAntiBottler()
+ {
Implementation eventlist[] = { I_OnPreCommand };
ServerInstance->Modules->Attach(eventlist, this, 1);
class AuditoriumMode : public ModeHandler
{
public:
- AuditoriumMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'u', PARAM_NONE, MODETYPE_CHANNEL)
+ AuditoriumMode(Module* Creator) : ModeHandler(Creator, 'u', PARAM_NONE, MODETYPE_CHANNEL)
{
levelrequired = OP_VALUE;
}
bool ShowOps;
bool OperOverride;
public:
- ModuleAuditorium(InspIRCd* Me)
- : Module(Me), aum(Me, this)
+ ModuleAuditorium()
+ : aum(this)
{
if (!ServerInstance->Modes->AddMode(&aum))
throw ModuleException("Could not add new modes!");
OnRehash(NULL);
Implementation eventlist[] = { I_OnUserJoin, I_OnUserPart, I_OnUserKick, I_OnUserQuit, I_OnNamesListItem, I_OnRehash, I_OnHostCycle };
- Me->Modules->Attach(eventlist, this, 7);
+ ServerInstance->Modules->Attach(eventlist, this, 7);
}
void OnRehash(User* user)
{
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
ShowOps = conf.ReadFlag("auditorium", "showops", 0);
OperOverride = conf.ReadFlag("auditorium", "operoverride", 0);
}
class BanException : public ListModeBase
{
public:
- BanException(InspIRCd* Instance, Module* Creator) : ListModeBase(Instance, Creator, 'e', "End of Channel Exception List", 348, 349, true) { }
+ BanException(Module* Creator) : ListModeBase(Creator, 'e', "End of Channel Exception List", 348, 349, true) { }
};
BanException be;
public:
- ModuleBanException(InspIRCd* Me) : Module(Me), be(Me, this)
+ ModuleBanException() : be(this)
{
if (!ServerInstance->Modes->AddMode(&be))
throw ModuleException("Could not add new modes!");
be.DoImplements(this);
Implementation list[] = { I_OnRehash, I_OnRequest, I_On005Numeric, I_OnExtBanCheck, I_OnCheckChannelBan };
- Me->Modules->Attach(list, this, 5);
+ ServerInstance->Modules->Attach(list, this, 5);
}
{
public:
SimpleExtItem<BanRedirectList> extItem;
- BanRedirect(InspIRCd* Instance, Module* parent) : ModeWatcher(Instance, 'b', MODETYPE_CHANNEL),
+ BanRedirect(Module* parent) : ModeWatcher('b', MODETYPE_CHANNEL),
extItem("banredirect", parent)
{
}
Module* ExceptionModule;
public:
- ModuleBanRedirect(InspIRCd* Me)
- : Module(Me), re(Me, this)
+ ModuleBanRedirect()
+ : re(this)
{
nofollow = false;
Extensible::Register(&re.extItem);
Implementation list[] = { I_OnRehash, I_OnUserPreJoin, I_OnChannelDelete, I_OnCleanup };
- Me->Modules->Attach(list, this, 4);
+ ServerInstance->Modules->Attach(list, this, 4);
}
virtual void OnChannelDelete(Channel* chan)
if(redirects)
{
- irc::modestacker modestack(ServerInstance, false);
+ irc::modestacker modestack(false);
StringDeque stackresult;
std::vector<std::string> mode_junk;
mode_junk.push_back(chan->name);
user->WriteNumeric(474, "%s %s :Cannot join channel (You are banned)", user->nick.c_str(), chan->name.c_str());
user->WriteNumeric(470, "%s %s %s :You are banned from this channel, so you are automatically transfered to the redirected channel.", user->nick.c_str(), chan->name.c_str(), redir->targetchan.c_str());
nofollow = true;
- Channel::JoinUser(ServerInstance, user, redir->targetchan.c_str(), false, "", false, ServerInstance->Time());
+ Channel::JoinUser(user, redir->targetchan.c_str(), false, "", false, ServerInstance->Time());
nofollow = false;
return MOD_RES_ALLOW;
}
SimpleExtItem<BlockedMessage> blockamsg;
public:
- ModuleBlockAmsg(InspIRCd* Me) : Module(Me), blockamsg("blockamsg", this)
+ ModuleBlockAmsg() : blockamsg("blockamsg", this)
{
this->OnRehash(NULL);
Extensible::Register(&blockamsg);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
ForgetDelay = Conf.ReadInteger("blockamsg", "delay", 0, false);
class BlockCaps : public SimpleChannelModeHandler
{
public:
- BlockCaps(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'B') { }
+ BlockCaps(Module* Creator) : SimpleChannelModeHandler(Creator, 'B') { }
};
class ModuleBlockCAPS : public Module
char capsmap[256];
public:
- ModuleBlockCAPS(InspIRCd* Me) : Module(Me), bc(Me, this)
+ ModuleBlockCAPS() : bc(this)
{
OnRehash(NULL);
if (!ServerInstance->Modes->AddMode(&bc))
Channel* c = (Channel*)dest;
- if (CHANOPS_EXEMPT(ServerInstance, 'B') && c->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('B') && c->GetPrefixValue(user) == OP_VALUE)
{
return MOD_RES_PASSTHRU;
}
void ReadConf()
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
percent = Conf.ReadInteger("blockcaps", "percent", "100", 0, true);
minlen = Conf.ReadInteger("blockcaps", "minlen", "1", 0, true);
std::string hmap = Conf.ReadValue("blockcaps", "capsmap", 0);
class BlockColor : public SimpleChannelModeHandler
{
public:
- BlockColor(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'c') { }
+ BlockColor(Module* Creator) : SimpleChannelModeHandler(Creator, 'c') { }
};
class ModuleBlockColour : public Module
BlockColor bc;
public:
- ModuleBlockColour(InspIRCd* Me) : Module(Me), bc(Me, this)
+ ModuleBlockColour() : bc(this)
{
if (!ServerInstance->Modes->AddMode(&bc))
throw ModuleException("Could not add new modes!");
{
Channel* c = (Channel*)dest;
- if (CHANOPS_EXEMPT(ServerInstance, 'c') && c->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('c') && c->GetPrefixValue(user) == OP_VALUE)
{
return MOD_RES_PASSTHRU;
}
class BotMode : public SimpleUserModeHandler
{
public:
- BotMode(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Creator, 'B') { }
+ BotMode(Module* Creator) : SimpleUserModeHandler(Creator, 'B') { }
};
class ModuleBotMode : public Module
{
BotMode bm;
public:
- ModuleBotMode(InspIRCd* Me)
- : Module(Me), bm(Me, this)
+ ModuleBotMode()
+ : bm(this)
{
if (!ServerInstance->Modes->AddMode(&bm))
throw ModuleException("Could not add new modes!");
class User_g : public SimpleUserModeHandler
{
public:
- User_g(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Creator, 'g') { }
+ User_g(Module* Creator) : SimpleUserModeHandler(Creator, 'g') { }
};
class CommandAccept : public Command
}
public:
- ModuleCallerID(InspIRCd* Me) : Module(Me), cmd(this), myumode(Me, this)
+ ModuleCallerID() : cmd(this), myumode(this)
{
OnRehash(NULL);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
cmd.maxaccepts = Conf.ReadInteger("callerid", "maxaccepts", "16", 0, true);
operoverride = Conf.ReadFlag("callerid", "operoverride", "0", 0);
tracknick = Conf.ReadFlag("callerid", "tracknick", "0", 0);
reghold.set(user, 1);
Event event((char*) &Data, this->creator, "cap_req");
- event.Send(ServerInstance);
+ event.Send();
if (Data.ack.size() > 0)
{
reghold.set(user, 1);
Event event((char*) &Data, this->creator, subcommand == "LS" ? "cap_ls" : "cap_list");
- event.Send(ServerInstance);
+ event.Send();
std::string Result;
if (Data.wanted.size() > 0)
reghold.set(user, 1);
Event event((char*) &Data, this->creator, "cap_clear");
- event.Send(ServerInstance);
+ event.Send();
std::string Result = irc::stringjoiner(" ", Data.ack, 0, Data.ack.size() - 1).GetJoined();
user->WriteServ("CAP * ACK :%s", Result.c_str());
{
CommandCAP cmd;
public:
- ModuleCAP(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleCAP()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
Extensible::Register(&cmd.reghold);
public:
irc::string matchtext;
- CBan(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string ch)
- : XLine(Instance, s_time, d, src, re, "CBAN")
+ CBan(time_t s_time, long d, std::string src, std::string re, std::string ch)
+ : XLine(s_time, d, src, re, "CBAN")
{
this->matchtext = ch.c_str();
}
class CBanFactory : public XLineFactory
{
public:
- CBanFactory(InspIRCd* Instance) : XLineFactory(Instance, "CBAN") { }
+ CBanFactory() : XLineFactory("CBAN") { }
/** Generate a shun
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
- return new CBan(ServerInstance, set_time, duration, source, reason, xline_specific_mask);
+ return new CBan(set_time, duration, source, reason, xline_specific_mask);
}
bool AutoApplyToUserList(XLine *x)
try
{
- r = new CBan(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), reason, parameters[0].c_str());
+ r = new CBan(ServerInstance->Time(), duration, user->nick.c_str(), reason, parameters[0].c_str());
}
catch (...)
{
CBanFactory f;
public:
- ModuleCBan(InspIRCd* Me) : Module(Me), mycommand(this), f(Me)
+ ModuleCBan() : mycommand(this)
{
ServerInstance->XLines->RegisterFactory(&f);
class CensorUser : public SimpleUserModeHandler
{
public:
- CensorUser(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Creator, 'G') { }
+ CensorUser(Module* Creator) : SimpleUserModeHandler(Creator, 'G') { }
};
/** Handles channel mode +G
class CensorChannel : public SimpleChannelModeHandler
{
public:
- CensorChannel(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'G') { }
+ CensorChannel(Module* Creator) : SimpleChannelModeHandler(Creator, 'G') { }
};
class ModuleCensor : public Module
CensorChannel cc;
public:
- ModuleCensor(InspIRCd* Me)
- : Module(Me), cu(Me, this), cc(Me, this)
+ ModuleCensor()
+ : cu(this), cc(this)
{
/* Read the configuration file on startup.
*/
{
active = ((Channel*)dest)->IsModeSet('G');
Channel* c = (Channel*)dest;
- if (CHANOPS_EXEMPT(ServerInstance, 'G') && c->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('G') && c->GetPrefixValue(user) == OP_VALUE)
{
return MOD_RES_PASSTHRU;
}
* reload our config file on rehash - we must destroy and re-allocate the classes
* to call the constructor again and re-read our data.
*/
- ConfigReader* MyConf = new ConfigReader(ServerInstance);
+ ConfigReader* MyConf = new ConfigReader;
censors.clear();
for (int index = 0; index < MyConf->Enumerate("badword"); index++)
User* them;
bool notify;
public:
- CGIResolver(Module* me, InspIRCd* Instance, bool NotifyOpers, const std::string &source, bool forward, User* u, int userfd, const std::string &type, bool &cached)
- : Resolver(Instance, source, forward ? DNS_QUERY_A : DNS_QUERY_PTR4, cached, me), typ(type), theirfd(userfd), them(u), notify(NotifyOpers) { }
+ CGIResolver(Module* me, bool NotifyOpers, const std::string &source, bool forward, User* u, int userfd, const std::string &type, bool &cached)
+ : Resolver(source, forward ? DNS_QUERY_A : DNS_QUERY_PTR4, cached, me), typ(type), theirfd(userfd), them(u), notify(NotifyOpers) { }
virtual void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached)
{
CommandWebirc cmd;
bool NotifyOpers;
public:
- ModuleCgiIRC(InspIRCd* Me) : Module(Me), cmd(this, NotifyOpers)
+ ModuleCgiIRC() : cmd(this, NotifyOpers)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmd);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
cmd.Hosts.clear();
NotifyOpers = Conf.ReadFlag("cgiirc", "opernotice", 0); // If we send an oper notice when a CGI:IRC has their host changed.
{
bool cached;
- CGIResolver* r = new CGIResolver(this, ServerInstance, NotifyOpers, user->password, false, user, user->GetFd(), "PASS", cached);
+ CGIResolver* r = new CGIResolver(this, NotifyOpers, user->password, false, user, user->GetFd(), "PASS", cached);
ServerInstance->AddResolver(r, cached);
}
catch (...)
{
bool cached;
- CGIResolver* r = new CGIResolver(this, ServerInstance, NotifyOpers, newipstr, false, user, user->GetFd(), "IDENT", cached);
+ CGIResolver* r = new CGIResolver(this, NotifyOpers, newipstr, false, user, user->GetFd(), "IDENT", cached);
ServerInstance->AddResolver(r, cached);
}
catch (...)
{
private:
public:
- ModuleChanCreate(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleChanCreate()
+ {
ServerInstance->SNO->EnableSnomask('j', "CHANCREATE");
ServerInstance->SNO->EnableSnomask('J', "REMOTECHANCREATE");
Implementation eventlist[] = { I_OnUserJoin };
class ChanFilter : public ListModeBase
{
public:
- ChanFilter(InspIRCd* Instance, Module* Creator) : ListModeBase(Instance, Creator, 'g', "End of channel spamfilter list", 941, 940, false, "chanfilter") { }
+ ChanFilter(Module* Creator) : ListModeBase(Creator, 'g', "End of channel spamfilter list", 941, 940, false, "chanfilter") { }
virtual bool ValidateParam(User* user, Channel* chan, std::string &word)
{
public:
- ModuleChanFilter(InspIRCd* Me)
- : Module(Me), cf(Me, this)
+ ModuleChanFilter()
+ : cf(this)
{
if (!ServerInstance->Modes->AddMode(&cf))
throw ModuleException("Could not add new modes!");
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
hidemask = Conf.ReadFlag("chanfilter", "hidemask", 0);
cf.DoRehash();
}
virtual ModResult ProcessMessages(User* user,Channel* chan,std::string &text)
{
- if (!IS_LOCAL(user) || (CHANOPS_EXEMPT(ServerInstance, 'g') && chan->GetPrefixValue(user) == OP_VALUE))
+ if (!IS_LOCAL(user) || (CHANOPS_EXEMPT('g') && chan->GetPrefixValue(user) == OP_VALUE))
return MOD_RES_PASSTHRU;
modelist* list = cf.extItem.get(chan);
std::multimap<char, std::string> logstreams;
public:
- ModuleChanLog(InspIRCd* Me) : Module(Me)
- {
+ ModuleChanLog() {
Implementation eventlist[] = { I_OnRehash, I_OnSendSnotice };
ServerInstance->Modules->Attach(eventlist, this, 2);
virtual void OnRehash(User *user)
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
std::string snomasks;
std::string channel;
std::string channel;
public:
- ChannelLogStream(InspIRCd *Instance, int loglevel, const std::string &chan) : LogStream(Instance, loglevel), channel(chan)
+ ChannelLogStream(int loglevel, const std::string &chan) : LogStream(loglevel), channel(chan)
{
}
class NewIsChannelHandler : public HandlerBase2<bool, const char*, size_t>
{
- InspIRCd* Server;
public:
- NewIsChannelHandler(InspIRCd* Srv) : Server(Srv) { }
+ NewIsChannelHandler() { }
virtual ~NewIsChannelHandler() { }
virtual bool Call(const char*, size_t);
};
class ModuleChannelNames : public Module
{
private:
- InspIRCd* ServerInstance;
- NewIsChannelHandler* myhandler;
- caller2<bool, const char*, size_t> * rememberer;
+ NewIsChannelHandler myhandler;
+ caller2<bool, const char*, size_t> rememberer;
bool badchan;
public:
- ModuleChannelNames(InspIRCd* Me) : Module(Me)
+ ModuleChannelNames() : rememberer(ServerInstance->IsChannel)
{
- rememberer = (caller2<bool, const char*, size_t> *) malloc(sizeof(caller2<bool, const char*, size_t>));
- ServerInstance = Me;
- *rememberer = ServerInstance->IsChannel;
- myhandler = new NewIsChannelHandler(ServerInstance);
- ServerInstance->IsChannel = myhandler;
+ ServerInstance->IsChannel = &myhandler;
badchan = false;
Implementation eventlist[] = { I_OnRehash, I_OnUserKick };
ServerInstance->Modules->Attach(eventlist, this, 2);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
std::string denyToken = Conf.ReadValue("channames", "denyrange", 0);
std::string allowToken = Conf.ReadValue("channames", "allowrange", 0);
memset(allowedmap, 1, sizeof(allowedmap));
virtual ~ModuleChannelNames()
{
- delete myhandler;
- ServerInstance->IsChannel = *rememberer;
- free(rememberer);
+ ServerInstance->IsChannel = rememberer;
ValidateChans();
}
{
private:
public:
- ModuleBadChannelExtban(InspIRCd* Me) : Module(Me)
- {
+ ModuleBadChannelExtban() {
Implementation eventlist[] = { I_OnCheckBan, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
const UserMembList* cl = channel->GetUsers();
std::vector<std::string> mode_junk;
mode_junk.push_back(channel->name);
- irc::modestacker modestack(ServerInstance, false);
+ irc::modestacker modestack(false);
std::deque<std::string> stackresult;
for (UserMembCIter i = cl->begin(); i != cl->end(); i++)
public:
- ModuleChanProtect(InspIRCd* Me)
- : Module(Me), FirstInGetsFounder(false), QPrefix(0), APrefix(0), DeprivSelf(false), DeprivOthers(false), booting(true), cp(NULL), cf(NULL)
+ ModuleChanProtect()
+ : FirstInGetsFounder(false), QPrefix(0), APrefix(0), DeprivSelf(false), DeprivOthers(false), booting(true), cp(NULL), cf(NULL)
{
/* Load config stuff */
LoadSettings();
void LoadSettings()
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
FirstInGetsFounder = Conf.ReadFlag("chanprotect", "noservices", 0);
private:
CommandCheck mycommand;
public:
- ModuleCheck(InspIRCd* Me) : Module(Me), mycommand(this)
+ ModuleCheck() : mycommand(this)
{
ServerInstance->AddCommand(&mycommand);
}
CommandChghost cmd;
char hostmap[256];
public:
- ModuleChgHost(InspIRCd* Me) : cmd(this, hostmap)
+ ModuleChgHost() : cmd(this, hostmap)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmd);
void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
std::string hmap = Conf.ReadValue("hostname", "charmap", 0);
if (hmap.empty())
CommandChgident cmd;
public:
- ModuleChgIdent(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleChgIdent() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
CommandChgname cmd;
public:
- ModuleChgName(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleChgName() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
void DoRehash()
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
bool lowercase;
/* These are *not* using the need_positive parameter of ReadInteger -
CloakUser* cu;
public:
- ModuleCloaking(InspIRCd*)
+ ModuleCloaking()
{
/* Attempt to locate the md5 service provider, bail if we can't find it */
Module* HashModule = ServerInstance->Modules->Find("m_md5.so");
private:
CommandClones cmd;
public:
- ModuleClones(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleClones() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandClose cmd;
public:
- ModuleClose(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleClose()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
class PrivacyMode : public ModeHandler
{
public:
- PrivacyMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'c', PARAM_NONE, MODETYPE_USER) { }
+ PrivacyMode(Module* Creator) : ModeHandler(Creator, 'c', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
{
PrivacyMode pm;
public:
- ModulePrivacyMode(InspIRCd* Me) : Module(Me), pm(Me, this)
+ ModulePrivacyMode() : pm(this)
{
if (!ServerInstance->Modes->AddMode(&pm))
throw ModuleException("Could not add new modes!");
}
public:
- ModuleConnJoin(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleConnJoin()
+ {
OnRehash(NULL);
Implementation eventlist[] = { I_OnPostConnect, I_OnRehash };
ServerInstance->Modules->Attach(eventlist, this, 2);
virtual void OnRehash(User* user)
{
- ConfigReader* conf = new ConfigReader(ServerInstance);
+ ConfigReader* conf = new ConfigReader;
JoinChan = conf->ReadValue("autojoin", "channel", 0);
Joinchans.clear();
if (!JoinChan.empty())
for(std::vector<std::string>::iterator it = Joinchans.begin(); it != Joinchans.end(); it++)
if (ServerInstance->IsChannel(it->c_str(), ServerInstance->Config->Limits.ChanMax))
- Channel::JoinUser(ServerInstance, user, it->c_str(), false, "", false, ServerInstance->Time());
+ Channel::JoinUser(user, it->c_str(), false, "", false, ServerInstance->Time());
}
};
ConfigReader *Conf;
public:
- ModuleModesOnConnect(InspIRCd* Me) : Module(Me)
- {
+ ModuleModesOnConnect() {
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
Implementation eventlist[] = { I_OnUserConnect, I_OnRehash };
ServerInstance->Modules->Attach(eventlist, this, 2);
// for things like +x on connect, important, otherwise we have to resort to config order (bleh) -- w00t
virtual void OnRehash(User* user)
{
delete Conf;
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
}
virtual ~ModuleModesOnConnect()
LocalStringExt ext;
public:
- ModuleWaitPong(InspIRCd* Me)
- : Module(Me), ext("waitpong_pingstr", this)
+ ModuleWaitPong()
+ : ext("waitpong_pingstr", this)
{
OnRehash(NULL);
Implementation eventlist[] = { I_OnUserRegister, I_OnCheckReady, I_OnPreCommand, I_OnRehash };
void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
sendsnotice = Conf.ReadFlag("waitpong", "sendsnotice", 0);
unsigned int ipv4_cidr;
unsigned int ipv6_cidr;
public:
- ModuleConnectBan(InspIRCd* Me) : Module(Me)
- {
+ ModuleConnectBan() {
Implementation eventlist[] = { I_OnUserConnect, I_OnGarbageCollect, I_OnRehash };
ServerInstance->Modules->Attach(eventlist, this, 3);
OnRehash(NULL);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
std::string duration;
ipv4_cidr = Conf.ReadInteger("connectban", "ipv4cidr", 0, true);
if (i->second >= threshold)
{
// Create zline for set duration.
- ZLine* zl = new ZLine(ServerInstance, ServerInstance->Time(), banduration, ServerInstance->Config->ServerName, "Connect flooding", u->GetCIDRMask(range));
+ ZLine* zl = new ZLine(ServerInstance->Time(), banduration, ServerInstance->Config->ServerName, "Connect flooding", u->GetCIDRMask(range));
if (ServerInstance->XLines->AddLine(zl,NULL))
ServerInstance->XLines->ApplyLines();
else
public:
- ModuleConnFlood(InspIRCd* Me) : Module(Me)
- {
+ ModuleConnFlood() {
InitConf();
Implementation eventlist[] = { I_OnRehash, I_OnUserRegister };
void InitConf()
{
/* read configuration variables */
- conf = new ConfigReader(ServerInstance);
+ conf = new ConfigReader;
/* throttle configuration */
seconds = conf->ReadInteger("connflood", "seconds", 0, true);
maxconns = conf->ReadInteger("connflood", "maxconns", 0, true);
snprintf(TheHost,MAXBUF,"%s@%s",user->ident.c_str(), user->host.c_str());
snprintf(TheIP, MAXBUF,"%s@%s",user->ident.c_str(), user->GetIPString());
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
for (int i=0; i<Conf.Enumerate("title"); i++)
{
std::string name = Conf.ReadValue("title", "name", "", i);
CommandTitle cmd;
public:
- ModuleCustomTitle(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleCustomTitle() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
Extensible::Register(&cmd.ctitle);
if (!channel->PartUser(user, reason))
delete channel;
- Channel::JoinUser(ServerInstance, user, parameters[0].c_str(), true, "", false, ServerInstance->Time());
+ Channel::JoinUser(user, parameters[0].c_str(), true, "", false, ServerInstance->Time());
}
return CMD_SUCCESS;
{
CommandCycle cmd;
public:
- ModuleCycle(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleCycle()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
CommandDccallow cmd;
public:
- ModuleDCCAllow(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleDCCAllow()
+ : cmd(this)
{
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
ext = new SimpleExtItem<dccallowlist>("dccallow", this);
Extensible::Register(ext);
ServerInstance->AddCommand(&cmd);
virtual void OnRehash(User* user)
{
delete Conf;
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
ReadFileConf();
}
class User_d : public ModeHandler
{
public:
- User_d(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'd', PARAM_NONE, MODETYPE_USER) { }
+ User_d(Module* Creator) : ModeHandler(Creator, 'd', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
std::string deaf_bypasschars_uline;
public:
- ModuleDeaf(InspIRCd* Me)
- : Module(Me), m1(Me, this)
+ ModuleDeaf()
+ : m1(this)
{
if (!ServerInstance->Modes->AddMode(&m1))
throw ModuleException("Could not add new modes!");
virtual void OnRehash(User* user)
{
- ConfigReader* conf = new ConfigReader(ServerInstance);
+ ConfigReader* conf = new ConfigReader;
deaf_bypasschars = conf->ReadValue("deaf", "bypasschars", 0);
deaf_bypasschars_uline = conf->ReadValue("deaf", "bypasscharsuline", 0);
private:
CUList empty;
public:
- DelayJoinMode(InspIRCd* Instance, Module* Parent) : ModeHandler(Parent, 'D', PARAM_NONE, MODETYPE_CHANNEL)
+ DelayJoinMode(Module* Parent) : ModeHandler(Parent, 'D', PARAM_NONE, MODETYPE_CHANNEL)
{
levelrequired = OP_VALUE;
}
DelayJoinMode djm;
public:
LocalIntExt unjoined;
- ModuleDelayJoin(InspIRCd* Me) : Module(Me), djm(Me, this), unjoined("delayjoin", this)
+ ModuleDelayJoin() : djm(this), unjoined("delayjoin", this)
{
if (!ServerInstance->Modes->AddMode(&djm))
throw ModuleException("Could not add new modes!");
CUList empty;
public:
LocalIntExt jointime;
- DelayMsgMode(InspIRCd* Instance, Module* Parent) : ModeHandler(Parent, 'd', PARAM_SETONLY, MODETYPE_CHANNEL)
+ DelayMsgMode(Module* Parent) : ModeHandler(Parent, 'd', PARAM_SETONLY, MODETYPE_CHANNEL)
, jointime("delaymsg", Parent)
{
levelrequired = OP_VALUE;
private:
DelayMsgMode djm;
public:
- ModuleDelayMsg(InspIRCd* Me) : Module(Me), djm(Me, this)
+ ModuleDelayMsg() : djm(this)
{
if (!ServerInstance->Modes->AddMode(&djm))
throw ModuleException("Could not add new modes!");
ConfigReader *Conf;
public:
- ModuleDenyChannels(InspIRCd* Me) : Module(Me)
- {
+ ModuleDenyChannels() {
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
Implementation eventlist[] = { I_OnUserPreJoin, I_OnRehash };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
virtual void OnRehash(User* user)
{
delete Conf;
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
/* check for redirect validity and loops/chains */
for (int i =0; i < Conf->Enumerate("badchan"); i++)
{
if ((!newchan) || (!(newchan->IsModeSet('L'))))
{
user->WriteNumeric(926, "%s %s :Channel %s is forbidden, redirecting to %s: %s",user->nick.c_str(),cname,cname,redirect.c_str(), reason.c_str());
- Channel::JoinUser(ServerInstance,user,redirect.c_str(),false,"",false,ServerInstance->Time());
+ Channel::JoinUser(user,redirect.c_str(),false,"",false,ServerInstance->Time());
return MOD_RES_DENY;
}
}
{
CommandDevoice cmd;
public:
- ModuleDeVoice(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleDeVoice() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
public:
- DNSBLResolver(Module *me, InspIRCd *Instance, const std::string &hostname, User* u, int userfd, DNSBLConfEntry *conf, bool &cached)
- : Resolver(Instance, hostname, DNS_QUERY_A, cached, me)
+ DNSBLResolver(Module *me, const std::string &hostname, User* u, int userfd, DNSBLConfEntry *conf, bool &cached)
+ : Resolver(hostname, DNS_QUERY_A, cached, me)
{
theirfd = userfd;
them = u;
}
case DNSBLConfEntry::I_KLINE:
{
- KLine* kl = new KLine(ServerInstance, ServerInstance->Time(), ConfEntry->duration, ServerInstance->Config->ServerName, reason.c_str(),
+ KLine* kl = new KLine(ServerInstance->Time(), ConfEntry->duration, ServerInstance->Config->ServerName, reason.c_str(),
"*", them->GetIPString());
if (ServerInstance->XLines->AddLine(kl,NULL))
{
}
case DNSBLConfEntry::I_GLINE:
{
- GLine* gl = new GLine(ServerInstance, ServerInstance->Time(), ConfEntry->duration, ServerInstance->Config->ServerName, reason.c_str(),
+ GLine* gl = new GLine(ServerInstance->Time(), ConfEntry->duration, ServerInstance->Config->ServerName, reason.c_str(),
"*", them->GetIPString());
if (ServerInstance->XLines->AddLine(gl,NULL))
{
}
case DNSBLConfEntry::I_ZLINE:
{
- ZLine* zl = new ZLine(ServerInstance, ServerInstance->Time(), ConfEntry->duration, ServerInstance->Config->ServerName, reason.c_str(),
+ ZLine* zl = new ZLine(ServerInstance->Time(), ConfEntry->duration, ServerInstance->Config->ServerName, reason.c_str(),
them->GetIPString());
if (ServerInstance->XLines->AddLine(zl,NULL))
{
return DNSBLConfEntry::I_UNKNOWN;
}
public:
- ModuleDNSBL(InspIRCd *Me) : Module(Me)
- {
+ ModuleDNSBL() {
ReadConf();
Implementation eventlist[] = { I_OnRehash, I_OnUserRegister, I_OnStats };
ServerInstance->Modules->Attach(eventlist, this, 3);
*/
virtual void ReadConf()
{
- ConfigReader *MyConf = new ConfigReader(ServerInstance);
+ ConfigReader *MyConf = new ConfigReader;
ClearEntries();
for (int i=0; i< MyConf->Enumerate("dnsbl"); i++)
/* now we'd need to fire off lookups for `hostname'. */
bool cached;
- DNSBLResolver *r = new DNSBLResolver(this, ServerInstance, hostname, user, user->GetFd(), *i, cached);
+ DNSBLResolver *r = new DNSBLResolver(this, hostname, user, user->GetFd(), *i, cached);
ServerInstance->AddResolver(r, cached);
}
}
{
FilterBase* Base;
public:
- CommandFilter(FilterBase* f, const std::string &ssource)
+ CommandFilter(FilterBase* f)
: Command(reinterpret_cast<Module*>(f), "FILTER", 1, 5), Base(f)
{
flags_needed = 'o';
protected:
std::vector<std::string> exemptfromfilter; // List of channel names excluded from filtering.
public:
- FilterBase(InspIRCd* Me, const std::string &source);
+ FilterBase();
virtual ~FilterBase();
virtual ModResult OnUserPreMessage(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list);
virtual FilterResult* FilterMatch(User* user, const std::string &text, int flags) = 0;
return true;
}
-FilterBase::FilterBase(InspIRCd* Me, const std::string &source) : Module(Me), filtcommand(this, source)
+FilterBase::FilterBase() : filtcommand(this)
{
- Me->Modules->UseInterface("RegularExpression");
+ ServerInstance->Modules->UseInterface("RegularExpression");
ServerInstance->AddCommand(&filtcommand);
Implementation eventlist[] = { I_OnPreCommand, I_OnStats, I_OnSyncNetwork, I_OnDecodeMetaData, I_OnUserPreMessage, I_OnUserPreNotice, I_OnRehash, I_OnLoadModule };
ServerInstance->Modules->Attach(eventlist, this, 8);
}
if (f->action == "gline")
{
- GLine* gl = new GLine(ServerInstance, ServerInstance->Time(), f->gline_time, ServerInstance->Config->ServerName, f->reason.c_str(), "*", user->GetIPString());
+ GLine* gl = new GLine(ServerInstance->Time(), f->gline_time, ServerInstance->Config->ServerName, f->reason.c_str(), "*", user->GetIPString());
if (ServerInstance->XLines->AddLine(gl,NULL))
{
ServerInstance->XLines->ApplyLines();
if (f->action == "gline")
{
/* Note: We gline *@IP so that if their host doesnt resolve the gline still applies. */
- GLine* gl = new GLine(ServerInstance, ServerInstance->Time(), f->gline_time, ServerInstance->Config->ServerName, f->reason.c_str(), "*", user->GetIPString());
+ GLine* gl = new GLine(ServerInstance->Time(), f->gline_time, ServerInstance->Config->ServerName, f->reason.c_str(), "*", user->GetIPString());
if (ServerInstance->XLines->AddLine(gl,NULL))
{
ServerInstance->XLines->ApplyLines();
void FilterBase::OnRehash(User* user)
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
std::vector<std::string>().swap(exemptfromfilter);
for (int index = 0; index < MyConf.Enumerate("exemptfromfilter"); ++index)
{
/* Force a rehash to make sure that any filters that couldnt be applied from the conf
* on startup or on load are applied right now.
*/
- ConfigReader Config(ServerInstance);
+ ConfigReader Config;
ServerInstance->SNO->WriteGlobalSno('a', "Found and activated regex module '%s' for m_filter.so.", RegexEngine.c_str());
ReadFilters(Config);
}
ImplFilter fr;
public:
- ModuleFilter(InspIRCd* Me)
- : FilterBase(Me, "m_filter.so")
+ ModuleFilter()
{
OnRehash(NULL);
}
virtual void OnRehash(User* user)
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
FilterBase::OnRehash(user);
ReadFilters(MyConf);
}
{
private:
public:
- ModuleGecosBan(InspIRCd* Me) : Module(Me)
- {
+ ModuleGecosBan() {
Implementation eventlist[] = { I_OnCheckBan, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
CommandGreloadmodule cmd3;
public:
- ModuleGlobalLoad(InspIRCd* Me)
- : Module(Me), cmd1(this), cmd2(this), cmd3(this)
+ ModuleGlobalLoad()
+ : cmd1(this), cmd2(this), cmd3(this)
{
ServerInstance->AddCommand(&cmd1);
ServerInstance->AddCommand(&cmd2);
{
CommandGlobops cmd;
public:
- ModuleGlobops(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleGlobops()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
ServerInstance->SNO->EnableSnomask('g',"GLOBOPS");
class Helpop : public ModeHandler
{
public:
- Helpop(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'h', PARAM_NONE, MODETYPE_USER)
+ Helpop(Module* Creator) : ModeHandler(Creator, 'h', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
Helpop ho;
public:
- ModuleHelpop(InspIRCd* Me)
- : Module(Me), cmd(this), ho(Me, this)
+ ModuleHelpop()
+ : cmd(this), ho(this)
{
ReadConfig();
if (!ServerInstance->Modes->AddMode(&ho))
virtual void ReadConfig()
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
helpop_map.clear();
class HideChans : public ModeHandler
{
public:
- HideChans(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'I', PARAM_NONE, MODETYPE_USER) { }
+ HideChans(Module* Creator) : ModeHandler(Creator, 'I', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
bool AffectsOpers;
HideChans hm;
public:
- ModuleHideChans(InspIRCd* Me) : Module(Me), hm(Me, this)
+ ModuleHideChans() : hm(this)
{
if (!ServerInstance->Modes->AddMode(&hm))
throw ModuleException("Could not add new modes!");
virtual void OnRehash(User* user)
{
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
AffectsOpers = conf.ReadFlag("hidechans", "affectsopers", 0);
}
class HideOper : public ModeHandler
{
public:
- HideOper(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'H', PARAM_NONE, MODETYPE_USER)
+ HideOper(Module* Creator) : ModeHandler(Creator, 'H', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
{
HideOper hm;
public:
- ModuleHideOper(InspIRCd* Me)
- : Module(Me), hm(Me, this)
+ ModuleHideOper()
+ : hm(this)
{
if (!ServerInstance->Modes->AddMode(&hm))
std::string MySeparator;
public:
- ModuleHostChange(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleHostChange()
+ {
OnRehash(NULL);
Implementation eventlist[] = { I_OnRehash, I_OnUserConnect };
ServerInstance->Modules->Attach(eventlist, this, 2);
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
MySuffix = Conf.ReadValue("host","suffix",0);
MyPrefix = Conf.ReadValue("host","prefix","",0);
MySeparator = Conf.ReadValue("host","separator",".",0);
claimed = false;
HTTPRequest httpr(request_type,uri,&headers,this,ip,postdata);
Event acl((char*)&httpr, (Module*)HttpModule, "httpd_acl");
- acl.Send(ServerInstance);
+ acl.Send();
if (!claimed)
{
Event e((char*)&httpr, (Module*)HttpModule, "httpd_url");
- e.Send(ServerInstance);
+ e.Send();
if (!claimed)
{
SendHTTPError(404);
FileReader* index;
public:
- HttpListener(InspIRCd* Instance, FileReader *idx, int port, const std::string &addr) : ListenSocketBase(Instance, port, addr)
+ HttpListener(FileReader *idx, int port, const std::string &addr) : ListenSocketBase(port, addr)
{
this->index = idx;
}
std::string indexfile;
FileReader* index;
HttpListener *http;
- ConfigReader c(ServerInstance);
+ ConfigReader c;
httpsocks.clear(); // XXX this will BREAK if this module is made rehashable
httplisteners.clear();
bindip = c.ReadValue("http", "ip", i);
port = c.ReadInteger("http", "port", i, true);
indexfile = c.ReadValue("http", "index", i);
- index = new FileReader(ServerInstance, indexfile);
+ index = new FileReader(indexfile);
if (!index->Exists())
throw ModuleException("Can't read index file: "+indexfile);
- http = new HttpListener(ServerInstance, index, port, (char *)bindip.c_str()); // XXX this cast SUCKS.
+ http = new HttpListener(index, port, (char *)bindip.c_str()); // XXX this cast SUCKS.
httplisteners.push_back(http);
}
}
- ModuleHttpServer(InspIRCd* Me) : Module(Me)
- {
+ ModuleHttpServer() {
ReadConfig();
HttpModule = this;
Implementation eventlist[] = { I_OnRequest };
void ReadConfig()
{
acl_list.clear();
- ConfigReader c(ServerInstance);
+ ConfigReader c;
int n_items = c.Enumerate("httpdacl");
for (int i = 0; i < n_items; ++i)
{
}
}
- ModuleHTTPAccessList(InspIRCd* Me) : Module(Me)
- {
+ ModuleHTTPAccessList() {
ReadConfig();
Implementation eventlist[] = { I_OnEvent, I_OnRequest };
ServerInstance->Modules->Attach(eventlist, this, 2);
void ReadConfig()
{
- ConfigReader c(ServerInstance);
+ ConfigReader c;
this->stylesheet = c.ReadValue("httpstats", "stylesheet", 0);
}
- ModuleHttpStats(InspIRCd* Me) : Module(Me)
- {
+ ModuleHttpStats() {
ReadConfig();
this->changed = true;
Implementation eventlist[] = { I_OnEvent, I_OnRequest };
void ReadConfig()
{
- ConfigReader c(ServerInstance);
+ ConfigReader c;
this->stylesheet = c.ReadValue("httpstats", "stylesheet", 0);
}
- ModuleHttpStats(InspIRCd* Me) : Module(Me)
- {
+ ModuleHttpStats() {
ReadConfig();
this->changed = true;
Implementation eventlist[] = { I_OnEvent, I_OnRequest };
{
private:
User *user; /* User we are attached to */
- InspIRCd* ServerInstance; /* Server instance */
bool done; /* True if lookup is finished */
std::string result; /* Holds the ident string if done */
public:
time_t age;
- IdentRequestSocket(InspIRCd *Server, User* u) : user(u), ServerInstance(Server), result(u->ident)
+ IdentRequestSocket(User* u) : user(u), result(u->ident)
{
age = ServerInstance->Time();
socklen_t size = 0;
ConfigReader *Conf;
SimpleExtItem<IdentRequestSocket> ext;
public:
- ModuleIdent(InspIRCd *Me) : Module(Me), ext("ident_socket", this)
+ ModuleIdent() : ext("ident_socket", this)
{
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
OnRehash(NULL);
Implementation eventlist[] = { I_OnRehash, I_OnUserRegister, I_OnCheckReady, I_OnCleanup, I_OnUserDisconnect };
ServerInstance->Modules->Attach(eventlist, this, 5);
virtual void OnRehash(User *user)
{
delete Conf;
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
RequestTimeout = Conf->ReadInteger("ident", "timeout", 0, true);
if (!RequestTimeout)
try
{
- IdentRequestSocket *isock = new IdentRequestSocket(ServerInstance, user);
+ IdentRequestSocket *isock = new IdentRequestSocket(user);
ext.set(user, isock);
}
catch (ModuleException &e)
class InvisibleMode : public ModeHandler
{
public:
- InvisibleMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'Q', PARAM_NONE, MODETYPE_USER)
+ InvisibleMode(Module* Creator) : ModeHandler(Creator, 'Q', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
class InvisibleDeOper : public ModeWatcher
{
public:
- InvisibleDeOper(InspIRCd* Instance) : ModeWatcher(Instance, 'o', MODETYPE_USER)
+ InvisibleDeOper() : ModeWatcher('o', MODETYPE_USER)
{
}
InvisibleMode qm;
InvisibleDeOper ido;
public:
- ModuleInvisible(InspIRCd* Me)
- : Module(Me), qm(Me, this), ido(Me)
+ ModuleInvisible() : qm(this)
{
if (!ServerInstance->Modes->AddMode(&qm))
throw ModuleException("Could not add new modes!");
* Now supports CIDR and IP addresses -- Brain
*/
-class InspIRCd* ServerInstance;
-
/** Handles channel mode +I
*/
class InviteException : public ListModeBase
{
public:
- InviteException(InspIRCd* Instance, Module* Creator) : ListModeBase(Instance, Creator, 'I', "End of Channel Invite Exception List", 346, 347, true) { }
+ InviteException(Module* Creator) : ListModeBase(Creator, 'I', "End of Channel Invite Exception List", 346, 347, true) { }
};
class ModuleInviteException : public Module
{
InviteException ie;
public:
- ModuleInviteException(InspIRCd* Me) : Module(Me), ie(Me, this)
+ ModuleInviteException() : ie(this)
{
if (!ServerInstance->Modes->AddMode(&ie))
throw ModuleException("Could not add new modes!");
*/
class joinfloodsettings : public classbase
{
- private:
- InspIRCd* ServerInstance;
public:
int secs;
int joins;
int counter;
bool locked;
- joinfloodsettings(InspIRCd *Instance, int b, int c) : ServerInstance(Instance), secs(b), joins(c)
+ joinfloodsettings(int b, int c) : secs(b), joins(c)
{
reset = ServerInstance->Time() + secs;
counter = 0;
{
public:
SimpleExtItem<joinfloodsettings> ext;
- JoinFlood(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'j', PARAM_SETONLY, MODETYPE_CHANNEL),
+ JoinFlood(Module* Creator) : ModeHandler(Creator, 'j', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("joinflood", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
if (!f)
{
parameter = ConvToStr(njoins) + ":" +ConvToStr(nsecs);
- f = new joinfloodsettings(ServerInstance, nsecs, njoins);
+ f = new joinfloodsettings(nsecs, njoins);
ext.set(channel, f);
channel->SetModeParam('j', parameter);
return MODEACTION_ALLOW;
// new mode param, replace old with new
if ((nsecs > 0) && (njoins > 0))
{
- f = new joinfloodsettings(ServerInstance, nsecs, njoins);
+ f = new joinfloodsettings(nsecs, njoins);
ext.set(channel, f);
channel->SetModeParam('j', parameter);
return MODEACTION_ALLOW;
public:
- ModuleJoinFlood(InspIRCd* Me)
- : Module(Me), jf(Me, this)
+ ModuleJoinFlood()
+ : jf(this)
{
if (!ServerInstance->Modes->AddMode(&jf))
{
CommandJumpserver js;
public:
- ModuleJumpServer(InspIRCd* Me) : js(this)
+ ModuleJumpServer() : js(this)
{
ServerInstance->AddCommand(&js);
Implementation eventlist[] = { I_OnUserRegister };
{
public:
SimpleExtItem<delaylist> ext;
- KickRejoin(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'J', PARAM_SETONLY, MODETYPE_CHANNEL),
+ KickRejoin(Module* Creator) : ModeHandler(Creator, 'J', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("norejoinusers", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
public:
- ModuleKickNoRejoin(InspIRCd* Me)
- : Module(Me), kr(Me, this)
+ ModuleKickNoRejoin()
+ : kr(this)
{
if (!ServerInstance->Modes->AddMode(&kr))
throw ModuleException("Could not add new modes!");
class Knock : public SimpleChannelModeHandler
{
public:
- Knock(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'K') { }
+ Knock(Module* Creator) : SimpleChannelModeHandler(Creator, 'K') { }
};
class ModuleKnock : public Module
CommandKnock cmd;
Knock kn;
public:
- ModuleKnock(InspIRCd* Me) : Module(Me), cmd(this), kn(Me, this)
+ ModuleKnock() : cmd(this), kn(this)
{
if (!ServerInstance->Modes->AddMode(&kn))
throw ModuleException("Could not add new modes!");
}
public:
- ModuleLockserv(InspIRCd* Me) : lockcommand(this, locked), unlockcommand(this, locked)
+ ModuleLockserv() : lockcommand(this, locked), unlockcommand(this, locked)
{
ResetLocked();
ServerInstance->AddCommand(&lockcommand);
{
std::string url;
public:
- ModuleMapHide(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleMapHide()
+ {
ServerInstance->Modules->Attach(I_OnPreCommand, this);
ServerInstance->Modules->Attach(I_OnRehash, this);
OnRehash(NULL);
void OnRehash(User* user)
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
url = MyConf.ReadValue("security", "maphide", 0);
}
public:
- ModuleMD5(InspIRCd* Me)
- : Module(Me), key(NULL), chars(NULL)
+ ModuleMD5()
+ : key(NULL), chars(NULL)
{
ServerInstance->Modules->PublishInterface("HashRequest", this);
Implementation eventlist[] = { I_OnRequest };
time_t reset;
std::map<User*,int> counters;
- floodsettings(InspIRCd *Instance, bool a, int b, int c) : ServerInstance(Instance), ban(a), secs(b), lines(c)
+ floodsettings(bool a, int b, int c) : ban(a), secs(b), lines(c)
{
reset = ServerInstance->Time() + secs;
};
{
public:
SimpleExtItem<floodsettings> ext;
- MsgFlood(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'f', PARAM_SETONLY, MODETYPE_CHANNEL),
+ MsgFlood(Module* Creator) : ModeHandler(Creator, 'f', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("messageflood", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
if (!f)
{
parameter = std::string(ban ? "*" : "") + ConvToStr(nlines) + ":" +ConvToStr(nsecs);
- f = new floodsettings(ServerInstance,ban,nsecs,nlines);
+ f = new floodsettings(ban,nsecs,nlines);
ext.set(channel, f);
channel->SetModeParam('f', parameter);
return MODEACTION_ALLOW;
{
if ((((nlines != f->lines) || (nsecs != f->secs) || (ban != f->ban))) && (((nsecs > 0) && (nlines > 0))))
{
- floodsettings *fs = new floodsettings(ServerInstance,ban,nsecs,nlines);
+ floodsettings *fs = new floodsettings(ban,nsecs,nlines);
ext.set(channel, fs);
channel->SetModeParam('f', parameter);
return MODEACTION_ALLOW;
public:
- ModuleMsgFlood(InspIRCd* Me)
- : Module(Me), mf(Me, this)
+ ModuleMsgFlood()
+ : mf(this)
{
if (!ServerInstance->Modes->AddMode(&mf))
throw ModuleException("Could not add new modes!");
ModResult ProcessMessages(User* user,Channel* dest, const std::string &text)
{
- if (!IS_LOCAL(user) || (CHANOPS_EXEMPT(ServerInstance, 'f') && dest->GetPrefixValue(user) == OP_VALUE))
+ if (!IS_LOCAL(user) || (CHANOPS_EXEMPT('f') && dest->GetPrefixValue(user) == OP_VALUE))
{
return MOD_RES_PASSTHRU;
}
{
private:
public:
- ModuleQuietBan(InspIRCd* Me) : Module(Me)
- {
+ ModuleQuietBan() {
Implementation eventlist[] = { I_OnUserPreMessage, I_OnUserPreNotice, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 3);
}
{
public:
GenericCap cap;
- ModuleNamesX(InspIRCd* Me) : Module(Me), cap(this, "multi-prefix")
+ ModuleNamesX() : cap(this, "multi-prefix")
{
Implementation eventlist[] = { I_OnPreCommand, I_OnNamesListItem, I_On005Numeric, I_OnEvent };
ServerInstance->Modules->Attach(eventlist, this, 4);
class lwbNickHandler : public HandlerBase2<bool, const char*, size_t>
{
- InspIRCd* Server;
public:
- lwbNickHandler(InspIRCd* Srv) : Server(Srv) { }
+ lwbNickHandler() { }
virtual ~lwbNickHandler() { }
virtual bool Call(const char*, size_t);
};
class ModuleNationalChars : public Module
{
private:
-
- InspIRCd* ServerInstance;
- lwbNickHandler* myhandler;
+ lwbNickHandler myhandler;
std::string charset, casemapping;
unsigned char m_additional[256], m_additionalUp[256], m_lower[256], m_upper[256];
- caller2<bool, const char*, size_t> * rememberer;
+ caller2<bool, const char*, size_t> rememberer;
bool forcequit;
const unsigned char * lowermap_rememberer;
public:
- ModuleNationalChars(InspIRCd* Me) : Module(Me)
+ ModuleNationalChars() : rememberer(ServerInstance->IsNick)
{
- rememberer = (caller2<bool, const char*, size_t> *) malloc(sizeof(caller2<bool, const char*, size_t>));
-
lowermap_rememberer = national_case_insensitive_map;
memcpy(m_lower, rfc_case_insensitive_map, 256);
national_case_insensitive_map = m_lower;
- ServerInstance = Me;
-
- *rememberer = ServerInstance->IsNick;
- myhandler = new lwbNickHandler(ServerInstance);
- ServerInstance->IsNick = myhandler;
+ ServerInstance->IsNick = &myhandler;
Implementation eventlist[] = { I_OnRehash, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 2);
virtual void OnRehash(User* user)
{
- ConfigReader* conf = new ConfigReader(ServerInstance);
+ ConfigReader* conf = new ConfigReader;
charset = conf->ReadValue("nationalchars", "file", 0);
casemapping = conf->ReadValue("nationalchars", "casemapping", charset, 0, false);
charset.insert(0, "../locales/");
virtual ~ModuleNationalChars()
{
- delete myhandler;
- ServerInstance->IsNick = *rememberer;
- free(rememberer);
+ ServerInstance->IsNick = rememberer;
national_case_insensitive_map = lowermap_rememberer;
CheckForceQuit("National characters module unloaded");
}
*/
class nickfloodsettings : public classbase
{
- private:
- InspIRCd* ServerInstance;
public:
int secs;
int nicks;
int counter;
bool locked;
- nickfloodsettings(InspIRCd *Instance, int b, int c) : ServerInstance(Instance), secs(b), nicks(c)
+ nickfloodsettings(int b, int c) : secs(b), nicks(c)
{
- reset = Instance->Time() + secs;
+ reset = ServerInstance->Time() + secs;
counter = 0;
locked = false;
};
{
public:
SimpleExtItem<nickfloodsettings> ext;
- NickFlood(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'F', PARAM_SETONLY, MODETYPE_CHANNEL),
+ NickFlood(Module* Creator) : ModeHandler(Creator, 'F', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("nickflood", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
if (!f)
{
parameter = ConvToStr(nnicks) + ":" +ConvToStr(nsecs);
- f = new nickfloodsettings(ServerInstance, nsecs, nnicks);
+ f = new nickfloodsettings(nsecs, nnicks);
ext.set(channel, f);
channel->SetModeParam('F', parameter);
return MODEACTION_ALLOW;
// new mode param, replace old with new
if ((nsecs > 0) && (nnicks > 0))
{
- f = new nickfloodsettings(ServerInstance, nsecs, nnicks);
+ f = new nickfloodsettings(nsecs, nnicks);
ext.set(channel, f);
channel->SetModeParam('F', parameter);
return MODEACTION_ALLOW;
public:
- ModuleNickFlood(InspIRCd* Me)
- : Module(Me), nf(Me, this)
+ ModuleNickFlood()
+ : nf(this)
{
if (!ServerInstance->Modes->AddMode(&nf))
throw ModuleException("Could not add new modes!");
nickfloodsettings *f = nf.ext.get(channel);
if (f)
{
- if (CHANOPS_EXEMPT(ServerInstance, 'F') && channel->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('F') && channel->GetPrefixValue(user) == OP_VALUE)
continue;
if (f->islocked())
nickfloodsettings *f = nf.ext.get(channel);
if (f)
{
- if (CHANOPS_EXEMPT(ServerInstance, 'F') && channel->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('F') && channel->GetPrefixValue(user) == OP_VALUE)
return;
/* moved this here to avoid incrementing the counter for nick
CommandNicklock cmd1;
CommandNickunlock cmd2;
public:
- ModuleNickLock(InspIRCd* Me)
- : Module(Me), locked("nick_locked", this), cmd1(this, locked), cmd2(this, locked)
+ ModuleNickLock()
+ : locked("nick_locked", this), cmd1(this, locked), cmd2(this, locked)
{
ServerInstance->AddCommand(&cmd1);
ServerInstance->AddCommand(&cmd2);
class NoCTCP : public ModeHandler
{
public:
- NoCTCP(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'C', PARAM_NONE, MODETYPE_CHANNEL) { }
+ NoCTCP(Module* Creator) : ModeHandler(Creator, 'C', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
public:
- ModuleNoCTCP(InspIRCd* Me)
- : Module(Me), nc(Me, this)
+ ModuleNoCTCP()
+ : nc(this)
{
if (!ServerInstance->Modes->AddMode(&nc))
throw ModuleException("Could not add new modes!");
{
Channel* c = (Channel*)dest;
- if (CHANOPS_EXEMPT(ServerInstance, 'C') && c->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('C') && c->GetPrefixValue(user) == OP_VALUE)
{
return MOD_RES_PASSTHRU;
}
class NoKicks : public SimpleChannelModeHandler
{
public:
- NoKicks(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'Q') { }
+ NoKicks(Module* Creator) : SimpleChannelModeHandler(Creator, 'Q') { }
};
class ModuleNoKicks : public Module
NoKicks nk;
public:
- ModuleNoKicks(InspIRCd* Me)
- : Module(Me), nk(Me, this)
+ ModuleNoKicks()
+ : nk(this)
{
if (!ServerInstance->Modes->AddMode(&nk))
throw ModuleException("Could not add new modes!");
class NoNicks : public ModeHandler
{
public:
- NoNicks(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'N', PARAM_NONE, MODETYPE_CHANNEL) { }
+ NoNicks(Module* Creator) : ModeHandler(Creator, 'N', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
{
NoNicks nn;
public:
- ModuleNoNickChange(InspIRCd* Me) : Module(Me), nn(Me, this)
+ ModuleNoNickChange() : nn(this)
{
ServerInstance->Modes->AddMode(&nn);
Implementation eventlist[] = { I_OnUserPreNick, I_On005Numeric };
{
Channel* curr = *i;
- if (CHANOPS_EXEMPT(ServerInstance, 'N') && curr->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('N') && curr->GetPrefixValue(user) == OP_VALUE)
continue;
if (!curr->GetExtBanStatus(user, 'N').check(!curr->IsModeSet('N')))
class NoNotice : public SimpleChannelModeHandler
{
public:
- NoNotice(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'T') { }
+ NoNotice(Module* Creator) : SimpleChannelModeHandler(Creator, 'T') { }
};
class ModuleNoNotice : public Module
NoNotice nt;
public:
- ModuleNoNotice(InspIRCd* Me)
- : Module(Me), nt(Me, this)
+ ModuleNoNotice()
+ : nt(this)
{
if (!ServerInstance->Modes->AddMode(&nt))
throw ModuleException("Could not add new modes!");
// ulines are exempt.
return MOD_RES_PASSTHRU;
}
- else if (CHANOPS_EXEMPT(ServerInstance, 'T') && c->GetPrefixValue(user) == OP_VALUE)
+ else if (CHANOPS_EXEMPT('T') && c->GetPrefixValue(user) == OP_VALUE)
{
// channel ops are exempt if set in conf.
return MOD_RES_PASSTHRU;
{
private:
public:
- ModulePartMsgBan(InspIRCd* Me) : Module(Me)
- {
+ ModulePartMsgBan() {
Implementation eventlist[] = { I_OnUserPart, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
}
active = true;
- Channel* channel = Channel::JoinUser(ServerInstance, user, parameters[0].c_str(), false, "", false);
+ Channel* channel = Channel::JoinUser(user, parameters[0].c_str(), false, "", false);
active = false;
if (channel)
const UserMembList* cl = channel->GetUsers();
std::vector<std::string> mode_junk;
mode_junk.push_back(channel->name);
- irc::modestacker modestack(ServerInstance, false);
+ irc::modestacker modestack(false);
std::deque<std::string> stackresult;
for (UserMembCIter i = cl->begin(); i != cl->end(); i++)
public:
- ModuleOjoin(InspIRCd* Me)
- : Module(Me), np(NULL), mycommand(this)
+ ModuleOjoin()
+ : np(NULL), mycommand(this)
{
/* Load config stuff */
OnRehash(NULL);
void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
if (!np)
{
{
public:
/* This is an oper-only mode */
- OperChans(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'O', PARAM_NONE, MODETYPE_CHANNEL) { oper = true; }
+ OperChans(Module* Creator) : ModeHandler(Creator, 'O', PARAM_NONE, MODETYPE_CHANNEL) { oper = true; }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
{
OperChans oc;
public:
- ModuleOperChans(InspIRCd* Me)
- : Module(Me), oc(Me, this)
+ ModuleOperChans()
+ : oc(this)
{
if (!ServerInstance->Modes->AddMode(&oc))
throw ModuleException("Could not add new modes!");
{
private:
public:
- ModuleOperInvex(InspIRCd* Me) : Module(Me)
- {
+ ModuleOperInvex() {
Implementation eventlist[] = { I_OnCheckBan, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
}
public:
- ModuleOperjoin(InspIRCd* Me) : Module(Me)
- {
+ ModuleOperjoin() {
OnRehash(NULL);
Implementation eventlist[] = { I_OnPostOper, I_OnRehash };
ServerInstance->Modules->Attach(eventlist, this, 2);
virtual void OnRehash(User* user)
{
- ConfigReader* conf = new ConfigReader(ServerInstance);
+ ConfigReader* conf = new ConfigReader;
operChan = conf->ReadValue("operjoin", "channel", 0);
override = conf->ReadFlag("operjoin", "override", "0", 0);
for(std::vector<std::string>::iterator it = operChans.begin(); it != operChans.end(); it++)
if (ServerInstance->IsChannel(it->c_str(), ServerInstance->Config->Limits.ChanMax))
- Channel::JoinUser(ServerInstance, user, it->c_str(), override, "", false, ServerInstance->Time());
+ Channel::JoinUser(user, it->c_str(), override, "", false, ServerInstance->Time());
std::map<std::string, std::vector<std::string> >::iterator i = operTypeChans.find(user->oper);
{
if (ServerInstance->IsChannel(it->c_str(), ServerInstance->Config->Limits.ChanMax))
{
- Channel::JoinUser(ServerInstance, user, it->c_str(), override, "", false, ServerInstance->Time());
+ Channel::JoinUser(user, it->c_str(), override, "", false, ServerInstance->Time());
}
}
}
private:
ConfigReader* conf;
public:
- ModuleOperLevels(InspIRCd* Me)
- : Module(Me)
- {
- conf = new ConfigReader(ServerInstance);
+ ModuleOperLevels()
+ {
+ conf = new ConfigReader;
Implementation eventlist[] = { I_OnRehash, I_OnKill };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
virtual void OnRehash(User* user)
{
delete conf;
- conf = new ConfigReader(ServerInstance);
+ conf = new ConfigReader;
}
virtual Version GetVersion()
private:
public:
- ModuleOperLog(InspIRCd* Me) : Module(Me)
- {
+ ModuleOperLog() {
Implementation eventlist[] = { I_OnPreCommand, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 2);
ConfigReader *Conf;
public:
- ModuleModesOnOper(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleModesOnOper()
+ {
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
Implementation eventlist[] = { I_OnPostOper, I_OnRehash };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
virtual void OnRehash(User* user)
{
delete Conf;
- Conf = new ConfigReader(ServerInstance);
+ Conf = new ConfigReader;
}
virtual ~ModuleModesOnOper()
void LoadOperMOTD()
{
- ConfigReader* conf = new ConfigReader(ServerInstance);
+ ConfigReader* conf = new ConfigReader;
std::string filename;
filename = conf->ReadValue("opermotd","file",0);
if (opermotd)
delete opermotd;
opermotd = NULL;
}
- opermotd = new FileReader(ServerInstance, filename);
+ opermotd = new FileReader(filename);
onoper = conf->ReadFlag("opermotd","onoper","yes",0);
delete conf;
}
- ModuleOpermotd(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleOpermotd()
+ : cmd(this)
{
opermotd = NULL;
ServerInstance->AddCommand(&cmd);
- opermotd = new FileReader(ServerInstance);
+ opermotd = new FileReader;
LoadOperMOTD();
Implementation eventlist[] = { I_OnRehash, I_OnOper };
ServerInstance->Modules->Attach(eventlist, this, 2);
class OperPrefixMode : public ModeHandler
{
public:
- OperPrefixMode(InspIRCd* Instance, Module* Creator, char pfx) : ModeHandler(Creator, 'y', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ OperPrefixMode(Module* Creator, char pfx) : ModeHandler(Creator, 'y', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = pfx;
private:
OperPrefixMode* opm;
public:
- ModuleOperPrefixMode(InspIRCd* Me) : Module(Me)
- {
- ConfigReader Conf(ServerInstance);
+ ModuleOperPrefixMode() {
+ ConfigReader Conf;
std::string pfx = Conf.ReadValue("operprefix", "prefix", "!", 0, false);
- opm = new OperPrefixMode(ServerInstance, this, pfx[0]);
+ opm = new OperPrefixMode(this, pfx[0]);
if ((!ServerInstance->Modes->AddMode(opm)))
throw ModuleException("Could not add a new mode!");
public:
- ModuleOverride(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleOverride()
+ {
// read our config options (main config file)
OnRehash(NULL);
ServerInstance->SNO->EnableSnomask('G', "GODMODE");
void OnRehash(User* user)
{
// on a rehash we delete our classes for good measure and create them again.
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
// re-read our config options on a rehash
NoisyOverride = Conf.ReadFlag("override", "noisy", 0);
bool diduseiface; /* If we've called UseInterface yet. */
public:
- ModuleOperHash(InspIRCd* Me)
- : Module(Me), cmd(this, hashers, names)
+ ModuleOperHash()
+ : cmd(this, hashers, names)
{
diduseiface = false;
class PermChannel : public ModeHandler
{
public:
- PermChannel(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'P', PARAM_NONE, MODETYPE_CHANNEL) { }
+ PermChannel(Module* Creator) : ModeHandler(Creator, 'P', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
PermChannel p;
public:
- ModulePermanentChannels(InspIRCd* Me) : Module(Me), p(Me, this)
+ ModulePermanentChannels() : p(this)
{
if (!ServerInstance->Modes->AddMode(&p))
throw ModuleException("Could not add new modes!");
* Process config-defined list of permanent channels.
* -- w00t
*/
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
permchannelsconf = MyConf.ReadValue("permchanneldb", "filename", "", 0, false);
if (!c)
{
- c = new Channel(ServerInstance, channel, ServerInstance->Time());
+ c = new Channel(channel, ServerInstance->Time());
if (!topic.empty())
{
c->SetTopic(NULL, topic, true);
CommandRandquote cmd;
ConfigReader *conf;
public:
- ModuleRandQuote(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleRandQuote()
+ : cmd(this)
{
- conf = new ConfigReader(ServerInstance);
+ conf = new ConfigReader;
// Sort the Randomizer thingie..
srand(ServerInstance->Time());
throw ModuleException("m_randquote: Quotefile not specified - Please check your config.");
}
- quotes = new FileReader(ServerInstance, q_file);
+ quotes = new FileReader(q_file);
if(!quotes->Exists())
{
throw ModuleException("m_randquote: QuoteFile not Found!! Please check your config - module will not function.");
class Redirect : public ModeHandler
{
public:
- Redirect(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'L', PARAM_SETONLY, MODETYPE_CHANNEL) { }
+ Redirect(Module* Creator) : ModeHandler(Creator, 'L', PARAM_SETONLY, MODETYPE_CHANNEL) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
- ModuleRedirect(InspIRCd* Me)
- : Module(Me), re(Me, this)
+ ModuleRedirect()
+ : re(this)
{
if (!ServerInstance->Modes->AddMode(&re))
}
user->WriteNumeric(470, "%s %s %s :You may not join this channel, so you are automatically being transferred to the redirect channel.", user->nick.c_str(), cname, channel.c_str());
- Channel::JoinUser(ServerInstance, user, channel.c_str(), false, "", false, ServerInstance->Time());
+ Channel::JoinUser(user, channel.c_str(), false, "", false, ServerInstance->Time());
return MOD_RES_DENY;
}
}
{
protected:
std::string regex_string; // The raw uncompiled regex string.
- InspIRCd* ServerInstance;
// Constructor may as well be protected, as this class is abstract.
- Regex(const std::string& rx, InspIRCd* Me) : regex_string(rx), ServerInstance(Me)
+ Regex(const std::string& rx) : regex_string(rx)
{
}
class GlobRegex : public Regex
{
public:
- GlobRegex(const std::string& rx, InspIRCd* Me) : Regex(rx, Me)
+ GlobRegex(const std::string& rx) : Regex(rx)
{
}
class ModuleRegexGlob : public Module
{
public:
- ModuleRegexGlob(InspIRCd* Me) : Module(Me)
- {
- Me->Modules->PublishInterface("RegularExpression", this);
+ ModuleRegexGlob() {
+ ServerInstance->Modules->PublishInterface("RegularExpression", this);
Implementation eventlist[] = { I_OnRequest };
- Me->Modules->Attach(eventlist, this, 1);
+ ServerInstance->Modules->Attach(eventlist, this, 1);
}
virtual Version GetVersion()
{
RegexFactoryRequest* rfr = (RegexFactoryRequest*)request;
std::string rx = rfr->GetRegex();
- rfr->result = (Regex*)new GlobRegex(rx, ServerInstance);
+ rfr->result = new GlobRegex(rx);
return "OK";
}
return NULL;
class ModuleRegOnlyCreate : public Module
{
public:
- ModuleRegOnlyCreate(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleRegOnlyCreate()
+ {
Implementation eventlist[] = { I_OnUserPreJoin };
ServerInstance->Modules->Attach(eventlist, this, 1);
}
public:
- ModuleRemove(InspIRCd*) : cmd1(this, supportnokicks), cmd2(this, supportnokicks)
+ ModuleRemove() : cmd1(this, supportnokicks), cmd2(this, supportnokicks)
{
ServerInstance->AddCommand(&cmd1);
ServerInstance->AddCommand(&cmd2);
virtual void OnRehash(User* user)
{
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
supportnokicks = conf.ReadFlag("remove", "supportnokicks", 0);
}
void ReadConfig()
{
- ConfigReader* MyConf = new ConfigReader(ServerInstance);
+ ConfigReader* MyConf = new ConfigReader;
allowchans.clear();
for (int i = 0; i < MyConf->Enumerate("allowchannel"); i++)
{
}
public:
- ModuleRestrictChans(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleRestrictChans()
+ {
ReadConfig();
Implementation eventlist[] = { I_OnUserPreJoin, I_OnRehash };
public:
- ModuleRestrictMsg(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleRestrictMsg()
+ {
Implementation eventlist[] = { I_OnUserPreMessage, I_OnUserPreNotice };
ServerInstance->Modules->Attach(eventlist, this, 2);
byte *RMD(byte *message, dword length, unsigned int* key)
{
ServerInstance->Logs->Log("m_ripemd160", DEBUG, "RMD: '%s' length=%u", (const char*)message, length);
- dword MDbuf[RMDsize/32]; /* contains (A, B, C, D(, E)) */
+ dword MDbuf[RMDsize/32]; /* contains (A, B, C, D(E)) */
static byte hashcode[RMDsize/8]; /* for final hash-value */
dword X[16]; /* current 16-word chunk */
unsigned int i; /* counter */
public:
- ModuleRIPEMD160(InspIRCd* Me) : Module(Me), currkey(NULL), chars("0123456789abcdef")
+ ModuleRIPEMD160() : currkey(NULL), chars("0123456789abcdef")
{
ServerInstance->Modules->PublishInterface("HashRequest", this);
Implementation eventlist[] = { I_OnRequest };
* @param regex Pattern to match with
* @
*/
- RLine(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string regexs)
- : XLine(Instance, s_time, d, src, re, "R")
+ RLine(time_t s_time, long d, std::string src, std::string re, std::string regexs)
+ : XLine(s_time, d, src, re, "R")
{
matchtext = regexs;
void Apply(User* u)
{
if (ZlineOnMatch) {
- background_zlines.push_back(new ZLine(ServerInstance, ServerInstance->Time(), duration ? expiry - ServerInstance->Time() : 0, ServerInstance->Config->ServerName, reason.c_str(), u->GetIPString()));
+ background_zlines.push_back(new ZLine(ServerInstance->Time(), duration ? expiry - ServerInstance->Time() : 0, ServerInstance->Config->ServerName, reason.c_str(), u->GetIPString()));
}
DefaultApply(u, "R", false);
}
class RLineFactory : public XLineFactory
{
public:
- RLineFactory(InspIRCd* Instance) : XLineFactory(Instance, "R")
+ RLineFactory() : XLineFactory("R")
{
}
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
- return new RLine(ServerInstance, set_time, duration, source, reason, xline_specific_mask);
+ return new RLine(set_time, duration, source, reason, xline_specific_mask);
}
~RLineFactory()
try
{
- r = new RLine(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str());
+ r = new RLine(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str());
}
catch (ModuleException &e)
{
std::string RegexEngine;
public:
- ModuleRLine(InspIRCd* Me) : Module(Me), r(this), f(Me)
+ ModuleRLine() : r(this)
{
mymodule = this;
OnRehash(NULL);
- Me->Modules->UseInterface("RegularExpression");
+ ServerInstance->Modules->UseInterface("RegularExpression");
ServerInstance->AddCommand(&r);
ServerInstance->XLines->RegisterFactory(&f);
virtual void OnRehash(User *user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
if (!Conf.ReadFlag("rline", "zlineonmatch", 0) && ZlineOnMatch)
background_zlines.clear();
private:
public:
- ModuleRpcJson(InspIRCd *Me) : Module(Me)
+ ModuleRpcJson()
{
ServerInstance->Modules->PublishInterface("RPC", this);
Implementation eventlist[] = { I_OnEvent };
RPCRequest modreq("json", method->GetString(), params);
Event mev((char*) &modreq, this, "RPCMethod");
- mev.Send(ServerInstance);
+ mev.Send();
if (!modreq.claimed)
throw JsonException("Unrecognized method");
private:
public:
- ModuleRPCTest(InspIRCd *Me) : Module(Me)
- {
+ ModuleRPCTest() {
Implementation eventlist[] = { I_OnEvent };
ServerInstance->Modules->Attach(eventlist, this, 1);
}
SimpleExtItem<ListData> listData;
LocalIntExt listTime;
public:
- ModuleSafeList(InspIRCd* Me) : Module(Me), listData("safelist_data", this), listTime("safelist_last", this)
+ ModuleSafeList() : listData("safelist_data", this), listTime("safelist_last", this)
{
OnRehash(NULL);
Extensible::Register(&listData);
void OnRehash(User* user)
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
ThrottleSecs = MyConf.ReadInteger("safelist", "throttle", "60", 0, true);
LimitList = MyConf.ReadInteger("safelist", "maxlisters", "50", 0, true);
ServerNameSize = strlen(ServerInstance->Config->ServerName) + 4;
*/
if (IS_LOCAL(dest))
{
- Channel::JoinUser(ServerInstance, dest, parameters[1].c_str(), true, "", false, ServerInstance->Time());
+ Channel::JoinUser(dest, parameters[1].c_str(), true, "", false, ServerInstance->Time());
/* Fix for dotslasher and w00t - if the join didnt succeed, return CMD_FAILURE so that it doesnt propagate */
Channel* n = ServerInstance->FindChan(parameters[1]);
if (n)
{
CommandSajoin cmd;
public:
- ModuleSajoin(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSajoin()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandSakick cmd;
public:
- ModuleSakick(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSakick()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandSamode cmd;
public:
- ModuleSaMode(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSaMode()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
ServerInstance->Modules->Attach(I_OnPreMode, this);
{
CommandSanick cmd;
public:
- ModuleSanick(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSanick()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandSapart cmd;
public:
- ModuleSapart(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSapart()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandSaquit cmd;
public:
- ModuleSaquit(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSaquit()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
bool state_announced;
public:
- SaslAuthenticator(User *user_, std::string method, InspIRCd *instance, Module *ctor)
- : ServerInstance(instance), user(user_), state(SASL_INIT), state_announced(false)
+ SaslAuthenticator(User *user_, std::string method, Module *ctor)
+ : user(user_), state(SASL_INIT), state_announced(false)
{
parameterlist params;
params.push_back("*");
SaslAuthenticator *sasl = authExt.get(user);
if (!sasl)
- authExt.set(user, new SaslAuthenticator(user, parameters[0], ServerInstance, creator));
+ authExt.set(user, new SaslAuthenticator(user, parameters[0], creator));
else if (sasl->SendClientMessage(parameters) == false) // IAL abort extension --nenolod
{
sasl->AnnounceState();
CommandAuthenticate auth;
CommandSASL sasl;
public:
- ModuleSASL(InspIRCd* Me)
- : Module(Me), authExt("sasl_auth", this), cap(this, "sasl"), auth(this, authExt, cap), sasl(this, authExt)
+ ModuleSASL()
+ : authExt("sasl_auth", this), cap(this, "sasl"), auth(this, authExt, cap), sasl(this, authExt)
{
Implementation eventlist[] = { I_OnEvent, I_OnUserRegister, I_OnPostConnect, I_OnUserDisconnect, I_OnCleanup };
ServerInstance->Modules->Attach(eventlist, this, 5);
{
CommandSATopic cmd;
public:
- ModuleSATopic(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSATopic()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
std::vector<std::string> allowlist;
time_t WaitTime;
public:
- ModuleSecureList(InspIRCd* Me) : Module(Me)
- {
+ ModuleSecureList() {
OnRehash(NULL);
Implementation eventlist[] = { I_OnRehash, I_OnPreCommand, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 3);
void OnRehash(User* user)
{
- ConfigReader* MyConf = new ConfigReader(ServerInstance);
+ ConfigReader* MyConf = new ConfigReader;
allowlist.clear();
for (int i = 0; i < MyConf->Enumerate("securehost"); i++)
class ModuleSeeNicks : public Module
{
public:
- ModuleSeeNicks(InspIRCd* Me)
- : Module(Me)
- {
+ ModuleSeeNicks()
+ {
ServerInstance->SNO->EnableSnomask('n',"NICK");
ServerInstance->SNO->EnableSnomask('N',"REMOTENICK");
Implementation eventlist[] = { I_OnUserPostNick };
{
private:
public:
- ModuleServerBan(InspIRCd* Me) : Module(Me)
- {
+ ModuleServerBan() {
Implementation eventlist[] = { I_OnCheckBan, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 2);
}
{
public:
- Channel_r(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'r', PARAM_NONE, MODETYPE_CHANNEL) { }
+ Channel_r(Module* Creator) : ModeHandler(Creator, 'r', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
{
public:
- User_r(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'r', PARAM_NONE, MODETYPE_USER) { }
+ User_r(Module* Creator) : ModeHandler(Creator, 'r', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class AChannel_R : public SimpleChannelModeHandler
{
public:
- AChannel_R(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'R') { }
+ AChannel_R(Module* Creator) : SimpleChannelModeHandler(Creator, 'R') { }
};
/** User mode +R - unidentified users cannot message
class AUser_R : public SimpleUserModeHandler
{
public:
- AUser_R(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Creator, 'R') { }
+ AUser_R(Module* Creator) : SimpleUserModeHandler(Creator, 'R') { }
};
/** Channel mode +M - unidentified users cannot message channel
class AChannel_M : public SimpleChannelModeHandler
{
public:
- AChannel_M(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'M') { }
+ AChannel_M(Module* Creator) : SimpleChannelModeHandler(Creator, 'M') { }
};
class ModuleServicesAccount : public Module
User_r m5;
StringExtItem accountname;
public:
- ModuleServicesAccount(InspIRCd* Me) : Module(Me),
- m1(Me, this), m2(Me, this), m3(Me, this), m4(Me, this), m5(Me, this),
+ ModuleServicesAccount() : m1(this), m2(this), m3(this), m4(this), m5(this),
accountname("accountname", this)
{
ac.user = dest;
ac.account = *account;
Event n((char*)&ac, this, "account_login");
- n.Send(ServerInstance);
+ n.Send();
}
}
}
class ServProtectMode : public ModeHandler
{
public:
- ServProtectMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'k', PARAM_NONE, MODETYPE_USER) { oper = true; }
+ ServProtectMode(Module* Creator) : ModeHandler(Creator, 'k', PARAM_NONE, MODETYPE_USER) { oper = true; }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
{
ServProtectMode bm;
public:
- ModuleServProtectMode(InspIRCd* Me)
- : Module(Me), bm(Me, this)
+ ModuleServProtectMode()
+ : bm(this)
{
if (!ServerInstance->Modes->AddMode(&bm))
throw ModuleException("Could not add new modes!");
CommandSethost cmd;
char hostmap[256];
public:
- ModuleSetHost(InspIRCd* Me)
- : Module(Me), cmd(this, hostmap)
+ ModuleSetHost()
+ : cmd(this, hostmap)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmd);
void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
std::string hmap = Conf.ReadValue("hostname", "charmap", 0);
if (hmap.empty())
CommandSetident cmd;
public:
- ModuleSetIdent(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleSetIdent() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandSetidle cmd;
public:
- ModuleSetIdle(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSetIdle()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandSetname cmd;
public:
- ModuleSetName(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSetName()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
public:
- ModuleSHA256(InspIRCd* Me) : Module(Me), key(NULL), chars(NULL)
+ ModuleSHA256() : key(NULL), chars(NULL)
{
ServerInstance->Modules->PublishInterface("HashRequest", this);
Implementation eventlist[] = { I_OnRequest };
public:
- ModuleShowwhois(InspIRCd* Me) : cmd(this)
+ ModuleShowwhois() : cmd(this)
{
- ConfigReader conf(ServerInstance);
+ ConfigReader conf;
bool OpersOnly = conf.ReadFlag("showwhois", "opersonly", "yes", 0);
ShowWhoisFromOpers = conf.ReadFlag("showwhois", "showfromopers", "yes", 0);
public:
std::string matchtext;
- Shun(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string shunmask)
- : XLine(Instance, s_time, d, src, re, "SHUN")
+ Shun(time_t s_time, long d, std::string src, std::string re, std::string shunmask)
+ : XLine(s_time, d, src, re, "SHUN")
{
this->matchtext = shunmask;
}
class ShunFactory : public XLineFactory
{
public:
- ShunFactory(InspIRCd* Instance) : XLineFactory(Instance, "SHUN") { }
+ ShunFactory() : XLineFactory("SHUN") { }
/** Generate a shun
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
- return new Shun(ServerInstance, set_time, duration, source, reason, xline_specific_mask);
+ return new Shun(set_time, duration, source, reason, xline_specific_mask);
}
};
try
{
- r = new Shun(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), expr.c_str(), target.c_str());
+ r = new Shun(ServerInstance->Time(), duration, user->nick.c_str(), expr.c_str(), target.c_str());
}
catch (...)
{
bool affectopers;
public:
- ModuleShun(InspIRCd* Me) : Module(Me), cmd(this), f(Me)
+ ModuleShun() : cmd(this)
{
ServerInstance->XLines->RegisterFactory(&f);
ServerInstance->AddCommand(&cmd);
virtual void OnRehash(User* user)
{
- ConfigReader MyConf(ServerInstance);
+ ConfigReader MyConf;
std::string cmds = MyConf.ReadValue("shun", "enabledcommands", 0);
if (cmds.empty())
CommandSVSSilence cmdsvssilence;
public:
- ModuleSilence(InspIRCd* Me)
- : Module(Me), maxsilence(32), cmdsilence(this, maxsilence), cmdsvssilence(this)
+ ModuleSilence()
+ : maxsilence(32), cmdsilence(this, maxsilence), cmdsvssilence(this)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmdsilence);
void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
maxsilence = Conf.ReadInteger("silence", "maxentries", 0, true);
if (!maxsilence)
maxsilence = 32;
/* $ModDep: m_spanningtree/cachetimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */
-CacheRefreshTimer::CacheRefreshTimer(InspIRCd *Inst, SpanningTreeUtilities *Util) : Timer(3600, Inst->Time(), true), Instance(Inst), Utils(Util)
+CacheRefreshTimer::CacheRefreshTimer(SpanningTreeUtilities *Util) : Timer(3600, ServerInstance->Time(), true), Utils(Util)
{
}
class ModuleSpanningTree;
class SpanningTreeUtilities;
-class InspIRCd;
/** Create a timer which recurs every second, we inherit from Timer.
* Timer is only one-shot however, so at the end of each Tick() we simply
class CacheRefreshTimer : public Timer
{
private:
- InspIRCd *Instance;
SpanningTreeUtilities *Utils;
public:
- CacheRefreshTimer(InspIRCd *Instance, SpanningTreeUtilities* Util);
+ CacheRefreshTimer(SpanningTreeUtilities* Util);
virtual void Tick(time_t TIME);
};
if (params.size() < 3)
return true;
- irc::modestacker modestack(ServerInstance, true); /* Modes to apply from the users in the user list */
+ irc::modestacker modestack(true); /* Modes to apply from the users in the user list */
User* who = NULL; /* User we are currently checking */
std::string channel = params[0]; /* Channel name, as a string */
time_t TS = atoi(params[1].c_str()); /* Timestamp given to us for remote side */
if (created)
{
- chan = new Channel(ServerInstance, channel, TS);
+ chan = new Channel(channel, TS);
ServerInstance->SNO->WriteToSnoMask('d', "Creation FJOIN recieved for %s, timestamp: %lu", chan->name.c_str(), (unsigned long)TS);
}
else
for (std::string::iterator x = modes.begin(); x != modes.end(); ++x)
modestack.Push(*x, who->nick);
- Channel::JoinUser(ServerInstance, who, channel.c_str(), true, "", route_back_again->bursting, TS);
+ Channel::JoinUser(who, channel.c_str(), true, "", route_back_again->bursting, TS);
}
else
{
if (c)
{
- irc::modestacker stack(ServerInstance, false);
+ irc::modestacker stack(false);
parameterlist stackresult;
stackresult.push_back(c->name);
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */
-HandshakeTimer::HandshakeTimer(InspIRCd* Inst, TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay) : Timer(delay, Inst->Time(), true), Instance(Inst), sock(s), lnk(l), Utils(u)
+HandshakeTimer::HandshakeTimer(TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay)
+ : Timer(delay, ServerInstance->Time(), true), sock(s), lnk(l), Utils(u)
{
thefd = sock->GetFd();
}
class HandshakeTimer : public Timer
{
private:
- InspIRCd* Instance;
TreeSocket* sock;
Link* lnk;
SpanningTreeUtilities* Utils;
int thefd;
public:
- HandshakeTimer(InspIRCd* Inst, TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay);
+ HandshakeTimer(TreeSocket* s, Link* l, SpanningTreeUtilities* u, int delay);
~HandshakeTimer();
virtual void Tick(time_t TIME);
};
/* $ModDep: m_spanningtree/cachetimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h m_spanningtree/protocolinterface.h */
-ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me)
- : Module(Me), max_local(0), max_global(0)
+ModuleSpanningTree::ModuleSpanningTree()
+ : max_local(0), max_global(0)
{
ServerInstance->Modules->UseInterface("BufferedSocketHook");
- Utils = new SpanningTreeUtilities(ServerInstance, this);
+ Utils = new SpanningTreeUtilities(this);
command_rconnect = new CommandRConnect(this, Utils);
ServerInstance->AddCommand(command_rconnect);
command_rsquit = new CommandRSQuit(this, Utils);
ServerInstance->AddCommand(command_rsquit);
- RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils);
+ RefreshTimer = new CacheRefreshTimer(Utils);
ServerInstance->Timers->AddTimer(RefreshTimer);
Implementation eventlist[] =
ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
delete ServerInstance->PI;
- ServerInstance->PI = new SpanningTreeProtocolInterface(this, Utils, ServerInstance);
+ ServerInstance->PI = new SpanningTreeProtocolInterface(this, Utils);
loopCall = false;
// update our local user count
try
{
bool cached;
- ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached, start_type, y);
+ ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, x->IPAddr, *x, cached, start_type, y);
ServerInstance->AddResolver(snr, cached);
}
catch (ModuleException& e)
ModuleSpanningTree::~ModuleSpanningTree()
{
delete ServerInstance->PI;
- ServerInstance->PI = new ProtocolInterface(ServerInstance);
+ ServerInstance->PI = new ProtocolInterface;
/* This will also free the listeners */
delete Utils;
/** Constructor
*/
- ModuleSpanningTree(InspIRCd* Me);
+ ModuleSpanningTree();
/** Shows /LINKS
*/
{
if (params[0] == "*")
{
- FOREACH_MOD_I(ServerInstance,I_OnDecodeMetaData,OnDecodeMetaData(NULL,params[1],params[2]));
+ FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(NULL,params[1],params[2]));
}
else if (*(params[0].c_str()) == '#')
{
{
if (item)
item->unserialize(FORMAT_NETWORK, c, params[2]);
- FOREACH_MOD_I(ServerInstance,I_OnDecodeMetaData,OnDecodeMetaData(c,params[1],params[2]));
+ FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(c,params[1],params[2]));
}
}
else if (*(params[0].c_str()) != '#')
{
if (item)
item->unserialize(FORMAT_NETWORK, u, params[2]);
- FOREACH_MOD_I(ServerInstance,I_OnDecodeMetaData,OnDecodeMetaData(u,params[1],params[2]));
+ FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(u,params[1],params[2]));
}
}
}
/* Send everything else (channel modes, xlines etc) */
this->SendChannelModes(s);
this->SendXLines(s);
- FOREACH_MOD_I(ServerInstance,I_OnSyncNetwork,OnSyncNetwork(Utils->Creator,(void*)this));
+ FOREACH_MOD(I_OnSyncNetwork,OnSyncNetwork(Utils->Creator,(void*)this));
this->WriteLine(endburst);
ServerInstance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+name+"\2.");
}
Utils->Creator->ProtoSendMetaData(this, c->second, i->first, value);
}
- FOREACH_MOD_I(ServerInstance,I_OnSyncChannel,OnSyncChannel(c->second,Utils->Creator,this));
+ FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,Utils->Creator,this));
}
}
Utils->Creator->ProtoSendMetaData(this, u->second, i->first, value);
}
- FOREACH_MOD_I(ServerInstance,I_OnSyncUser,OnSyncUser(u->second,Utils->Creator,this));
+ FOREACH_MOD(I_OnSyncUser,OnSyncUser(u->second,Utils->Creator,this));
}
}
}
{
if (messagetype == "PRIVMSG")
{
- FOREACH_MOD_I(ServerInstance, I_OnUserMessage, OnUserMessage(Utils->ServerUser, channel, TYPE_CHANNEL, text, status, except_list));
+ FOREACH_MOD(I_OnUserMessage, OnUserMessage(Utils->ServerUser, channel, TYPE_CHANNEL, text, status, except_list));
}
else
{
- FOREACH_MOD_I(ServerInstance, I_OnUserNotice, OnUserNotice(Utils->ServerUser, channel, TYPE_CHANNEL, text, status, except_list));
+ FOREACH_MOD(I_OnUserNotice, OnUserNotice(Utils->ServerUser, channel, TYPE_CHANNEL, text, status, except_list));
}
TreeServer* s = Utils->FindServer(prefix);
if (s)
{
- FOREACH_MOD_I(ServerInstance, I_OnText, OnText(Utils->ServerUser, channel, TYPE_CHANNEL, text, status, except_list));
+ FOREACH_MOD(I_OnText, OnText(Utils->ServerUser, channel, TYPE_CHANNEL, text, status, except_list));
channel->WriteChannelWithServ(s->GetName().c_str(), "%s %s :%s", messagetype.c_str(), channel->name.c_str(), text.c_str());
}
}
{
if (messagetype == "PRIVMSG")
{
- FOREACH_MOD_I(ServerInstance, I_OnUserMessage, OnUserMessage(Utils->ServerUser, user, TYPE_USER, text, 0, except_list));
+ FOREACH_MOD(I_OnUserMessage, OnUserMessage(Utils->ServerUser, user, TYPE_USER, text, 0, except_list));
}
else
{
- FOREACH_MOD_I(ServerInstance, I_OnUserNotice, OnUserNotice(Utils->ServerUser, user, TYPE_USER, text, 0, except_list));
+ FOREACH_MOD(I_OnUserNotice, OnUserNotice(Utils->ServerUser, user, TYPE_USER, text, 0, except_list));
}
TreeServer* s = Utils->FindServer(prefix);
if (s)
{
- FOREACH_MOD_I(ServerInstance, I_OnText, OnText(Utils->ServerUser, user, TYPE_USER, text, status, except_list));
+ FOREACH_MOD(I_OnText, OnText(Utils->ServerUser, user, TYPE_USER, text, status, except_list));
user->Write(":%s %s %s :%s", s->GetName().c_str(), messagetype.c_str(), user->nick.c_str(), text.c_str());
}
ModuleSpanningTree* Module;
void SendChannel(Channel* target, char status, const std::string &text);
public:
- SpanningTreeProtocolInterface(ModuleSpanningTree* mod, SpanningTreeUtilities* util, InspIRCd* Instance) : ProtocolInterface(Instance), Utils(util), Module(mod) { }
+ SpanningTreeProtocolInterface(ModuleSpanningTree* mod, SpanningTreeUtilities* util) : Utils(util), Module(mod) { }
virtual ~SpanningTreeProtocolInterface() { }
virtual void SendEncapsulatedData(parameterlist &encap);
* callback to OnLookupComplete or OnError when completed. Once it has completed we
* will have an IP address which we can then use to continue our connection.
*/
-ServernameResolver::ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt, Autoconnect* myac) : Resolver(Instance, hostname, qt, cached, me), MyLink(x), Utils(Util), query(qt), host(hostname), mine(me), myautoconnect(myac)
+ServernameResolver::ServernameResolver(Module* me, SpanningTreeUtilities* Util, const std::string &hostname, Link x, bool &cached, QueryType qt, Autoconnect* myac) : Resolver(hostname, qt, cached, me), MyLink(x), Utils(Util), query(qt), host(hostname), mine(me), myautoconnect(myac)
{
/* Nothing in here, folks */
}
if (query == DNS_QUERY_AAAA)
{
bool cached;
- ServernameResolver* snr = new ServernameResolver(mine, Utils, ServerInstance, host, MyLink, cached, DNS_QUERY_A, myautoconnect);
+ ServernameResolver* snr = new ServernameResolver(mine, Utils, host, MyLink, cached, DNS_QUERY_A, myautoconnect);
ServerInstance->AddResolver(snr, cached);
return;
}
std::string host;
QueryType query;
public:
- SecurityIPResolver(Module* me, SpanningTreeUtilities* U, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt)
- : Resolver(Instance, hostname, qt, cached, me), MyLink(x), Utils(U), mine(me), host(hostname), query(qt)
+ SecurityIPResolver(Module* me, SpanningTreeUtilities* U, const std::string &hostname, Link x, bool &cached, QueryType qt)
+ : Resolver(hostname, qt, cached, me), MyLink(x), Utils(U), mine(me), host(hostname), query(qt)
{
}
if (query == DNS_QUERY_AAAA)
{
bool cached;
- SecurityIPResolver* res = new SecurityIPResolver(mine, Utils, ServerInstance, host, MyLink, cached, DNS_QUERY_A);
+ SecurityIPResolver* res = new SecurityIPResolver(mine, Utils, host, MyLink, cached, DNS_QUERY_A);
ServerInstance->AddResolver(res, cached);
return;
}
Module* mine;
Autoconnect* myautoconnect;
public:
- ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x, bool &cached, QueryType qt, Autoconnect* myac);
+ ServernameResolver(Module* me, SpanningTreeUtilities* Util, const std::string &hostname, Link x, bool &cached, QueryType qt, Autoconnect* myac);
void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached);
void OnError(ResolverError e, const std::string &errormessage);
};
Link* lnk = Utils->FindLink(servername);
- TreeServer *Node = new TreeServer(this->Utils, ServerInstance, servername, description, sid, ParentOfThis,NULL, lnk ? lnk->Hidden : false);
+ TreeServer *Node = new TreeServer(Utils, servername, description, sid, ParentOfThis,NULL, lnk ? lnk->Hidden : false);
ParentOfThis->AddChild(Node);
params[4] = ":" + params[4];
Utils->timeoutlist.erase(this);
- TreeServer *Node = new TreeServer(this->Utils, ServerInstance, sname, description, sid, Utils->TreeRoot, this, x->Hidden);
+ TreeServer *Node = new TreeServer(Utils, sname, description, sid, Utils->TreeRoot, this, x->Hidden);
Utils->TreeRoot->AddChild(Node);
params[4] = ":" + params[4];
{
/* only join if it's local, otherwise just pass it on! */
if (IS_LOCAL(u))
- Channel::JoinUser(ServerInstance, u, params[1].c_str(), false, "", false, ServerInstance->Time());
+ Channel::JoinUser(u, params[1].c_str(), false, "", false, ServerInstance->Time());
Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
}
return true;
* represents our own server. Therefore, it has no route, no parent, and
* no socket associated with it. Its version string is our own local version.
*/
-TreeServer::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, const std::string &id)
- : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc), Utils(Util)
+TreeServer::TreeServer(SpanningTreeUtilities* Util, std::string Name, std::string Desc, const std::string &id)
+ : ServerName(Name.c_str()), ServerDesc(Desc), Utils(Util)
{
- age = Instance->Time();
+ age = ServerInstance->Time();
bursting = false;
Parent = NULL;
VersionString.clear();
* This constructor initializes the server's Route and Parent, and sets up
* its ping counters so that it will be pinged one minute from now.
*/
-TreeServer::TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, const std::string &id, TreeServer* Above, TreeSocket* Sock, bool Hide)
- : ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock), Utils(Util), Hidden(Hide)
+TreeServer::TreeServer(SpanningTreeUtilities* Util, std::string Name, std::string Desc, const std::string &id, TreeServer* Above, TreeSocket* Sock, bool Hide)
+ : Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock), Utils(Util), Hidden(Hide)
{
- age = Instance->Time();
+ age = ServerInstance->Time();
bursting = true;
VersionString.clear();
ServerUserCount = ServerOperCount = 0;
gettimeofday(&t, NULL);
long ts = (t.tv_sec * 1000) + (t.tv_usec / 1000);
this->StartBurst = ts;
- Instance->Logs->Log("m_spanningtree",DEBUG, "Started bursting at time %lu", ts);
+ ServerInstance->Logs->Log("m_spanningtree",DEBUG, "Started bursting at time %lu", ts);
/* find the 'route' for this server (e.g. the one directly connected
* to the local server, which we can use to reach it)
ServerInstance->SNO->WriteToSnoMask(Parent == Utils->TreeRoot ? 'l' : 'L', "Received end of netburst from \2%s\2 (burst time: %lu %s)",
ServerName.c_str(), (bursttime > 10000 ? bursttime / 1000 : bursttime), (bursttime > 10000 ? "secs" : "msecs"));
Event rmode((char*)ServerName.c_str(), (Module*)Utils->Creator, "new_server");
- rmode.Send(ServerInstance);
+ rmode.Send();
}
void TreeServer::SetID(const std::string &id)
*/
class TreeServer : public classbase
{
- InspIRCd* ServerInstance; /* Creator */
TreeServer* Parent; /* Parent entry */
TreeServer* Route; /* Route entry */
std::vector<TreeServer*> Children; /* List of child objects */
* represents our own server. Therefore, it has no route, no parent, and
* no socket associated with it. Its version string is our own local version.
*/
- TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, const std::string &id);
+ TreeServer(SpanningTreeUtilities* Util, std::string Name, std::string Desc, const std::string &id);
/** When we create a new server, we call this constructor to initialize it.
* This constructor initializes the server's Route and Parent, and sets up
* its ping counters so that it will be pinged one minute from now.
*/
- TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, const std::string &id, TreeServer* Above, TreeSocket* Sock, bool Hide);
+ TreeServer(SpanningTreeUtilities* Util, std::string Name, std::string Desc, const std::string &id, TreeServer* Above, TreeSocket* Sock, bool Hide);
int QuitUsers(const std::string &reason);
if (HookMod)
BufferedSocketHookRequest(this, Utils->Creator, HookMod).Send();
- hstimer = new HandshakeTimer(ServerInstance, this, &(Utils->LinkBlocks[0]), this->Utils, 1);
+ hstimer = new HandshakeTimer(this, &(Utils->LinkBlocks[0]), this->Utils, 1);
ServerInstance->Timers->AddTimer(hstimer);
/* Fix by Brain - inbound sockets need a timeout, too. 30 secs should be pleanty */
if (GetIOHook())
{
ServerInstance->SNO->WriteToSnoMask('l', "Connection to \2%s\2[%s] using transport \2%s\2", myhost.c_str(), (x->HiddenFromStats ? "<hidden>" : this->IP.c_str()), x->Hook.c_str());
- hstimer = new HandshakeTimer(ServerInstance, this, &(*x), this->Utils, 1);
+ hstimer = new HandshakeTimer(this, &(*x), this->Utils, 1);
ServerInstance->Timers->AddTimer(hstimer);
}
else
if ((Current) && (Current != Utils->TreeRoot))
{
Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server");
- rmode.Send(ServerInstance);
+ rmode.Send();
parameterlist params;
params.push_back(Current->GetName());
Link* lnk = Utils->FindLink(InboundServerName);
- Node = new TreeServer(this->Utils, ServerInstance, InboundServerName, InboundDescription, InboundSID, Utils->TreeRoot, this, lnk ? lnk->Hidden : false);
+ Node = new TreeServer(this->Utils, InboundServerName, InboundDescription, InboundSID, Utils->TreeRoot, this, lnk ? lnk->Hidden : false);
Utils->TreeRoot->AddChild(Node);
parameterlist sparams;
User* _new = NULL;
try
{
- _new = new User(ServerInstance, params[0]);
+ _new = new User(params[0]);
}
catch (...)
{
params[params.size() - 1] = ":" + params[params.size() - 1];
Utils->DoOneToAllButSender(source, "UID", params, source);
- FOREACH_MOD_I(ServerInstance,I_OnPostConnect,OnPostConnect(_new));
+ FOREACH_MOD(I_OnPostConnect,OnPostConnect(_new));
return true;
}
return (FindServer(ServerName) != NULL);
}
-SpanningTreeUtilities::SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* C) : ServerInstance(Instance), Creator(C)
+SpanningTreeUtilities::SpanningTreeUtilities(ModuleSpanningTree* C) : Creator(C)
{
ServerInstance->Logs->Log("m_spanningtree",DEBUG,"***** Using SID for hash: %s *****", ServerInstance->Config->GetSID().c_str());
- this->TreeRoot = new TreeServer(this, ServerInstance, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc, ServerInstance->Config->GetSID());
- ServerUser = new FakeUser(ServerInstance, TreeRoot->GetID());
+ this->TreeRoot = new TreeServer(this, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc, ServerInstance->Config->GetSID());
+ ServerUser = new FakeUser(TreeRoot->GetID());
this->ReadConfiguration(true);
}
try
{
bool cached;
- SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L->IPAddr, *L, cached, start_type);
+ SecurityIPResolver* sr = new SecurityIPResolver(Creator, this, L->IPAddr, *L, cached, start_type);
ServerInstance->AddResolver(sr, cached);
}
catch (...)
void SpanningTreeUtilities::ReadConfiguration(bool rebind)
{
- ConfigReader* Conf = new ConfigReader(ServerInstance);
+ ConfigReader* Conf = new ConfigReader;
/* We don't need to worry about these being *unloaded* on the fly, only loaded,
* because we 'use' the interface locking the module in memory.
break;
}
- ServerSocketListener *listener = new ServerSocketListener(ServerInstance, this, portno, (char *)IP.c_str());
+ ServerSocketListener *listener = new ServerSocketListener(this, portno, (char *)IP.c_str());
if (listener->GetFd() == -1)
{
delete listener;
try
{
bool cached;
- SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L.IPAddr, L, cached, start_type);
+ SecurityIPResolver* sr = new SecurityIPResolver(Creator, this, L.IPAddr, L, cached, start_type);
ServerInstance->AddResolver(sr, cached);
}
catch (...)
SpanningTreeUtilities *Utils;
public:
- ServerSocketListener(InspIRCd* Instance, SpanningTreeUtilities *u, int port, char* addr) : ListenSocketBase(Instance, port, addr)
+ ServerSocketListener(SpanningTreeUtilities *u, int port, char* addr) : ListenSocketBase(port, addr)
{
this->Utils = u;
Hook = NULL;
*/
class SpanningTreeUtilities : public classbase
{
- private:
- /** Creator server
- */
- InspIRCd* ServerInstance;
public:
/** Creator module
*/
/** Initialise utility class
*/
- SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* Creator);
+ SpanningTreeUtilities(ModuleSpanningTree* Creator);
/** Destroy class and free listeners etc
*/
class ModuleSpy : public Module
{
public:
- ModuleSpy(InspIRCd* Me) : Module(Me)
- {
+ ModuleSpy() {
ServerInstance->Modules->Attach(I_OnUserList, this);
}
CommandSSLInfo cmd;
public:
- ModuleSSLInfo(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleSSLInfo()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
if ((pcmd == "OPER") && (validated))
{
- ConfigReader cf(ServerInstance);
+ ConfigReader cf;
char TheHost[MAXBUF];
char TheIP[MAXBUF];
std::string LoginName;
class SSLMode : public ModeHandler
{
public:
- SSLMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Creator, 'z', PARAM_NONE, MODETYPE_CHANNEL) { }
+ SSLMode(Module* Creator) : ModeHandler(Creator, 'z', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
SSLMode sslm;
public:
- ModuleSSLModes(InspIRCd* Me)
- : Module(Me), sslm(Me, this)
+ ModuleSSLModes()
+ : sslm(this)
{
if (!ServerInstance->Modes->AddMode(&sslm))
throw ModuleException("Could not add new modes!");
class ChannelStripColor : public SimpleChannelModeHandler
{
public:
- ChannelStripColor(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'S') { }
+ ChannelStripColor(Module* Creator) : SimpleChannelModeHandler(Creator, 'S') { }
};
/** Handles user mode +S
class UserStripColor : public SimpleUserModeHandler
{
public:
- UserStripColor(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Creator, 'S') { }
+ UserStripColor(Module* Creator) : SimpleUserModeHandler(Creator, 'S') { }
};
UserStripColor usc;
public:
- ModuleStripColor(InspIRCd* Me) : Module(Me), csc(Me, this), usc(Me, this)
+ ModuleStripColor() : csc(this), usc(this)
{
if (!ServerInstance->Modes->AddMode(&usc) || !ServerInstance->Modes->AddMode(&csc))
throw ModuleException("Could not add new modes!");
// check if we allow ops to bypass filtering, if we do, check if they're opped accordingly.
// note: short circut logic here, don't wreck it. -- w00t
- if (CHANOPS_EXEMPT(ServerInstance, 'S') && t->GetPrefixValue(user) == OP_VALUE)
+ if (CHANOPS_EXEMPT('S') && t->GetPrefixValue(user) == OP_VALUE)
{
return MOD_RES_PASSTHRU;
}
public:
irc::string nickname;
- SVSHold(InspIRCd* Instance, time_t s_time, long d, std::string src, std::string re, std::string nick)
- : XLine(Instance, s_time, d, src, re, "SVSHOLD")
+ SVSHold(time_t s_time, long d, std::string src, std::string re, std::string nick)
+ : XLine(s_time, d, src, re, "SVSHOLD")
{
this->nickname = nick.c_str();
}
class SVSHoldFactory : public XLineFactory
{
public:
- SVSHoldFactory(InspIRCd* Instance) : XLineFactory(Instance, "SVSHOLD") { }
+ SVSHoldFactory() : XLineFactory("SVSHOLD") { }
/** Generate a shun
*/
XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask)
{
- return new SVSHold(ServerInstance, set_time, duration, source, reason, xline_specific_mask);
+ return new SVSHold(set_time, duration, source, reason, xline_specific_mask);
}
};
try
{
- r = new SVSHold(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str());
+ r = new SVSHold(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str());
}
catch (...)
{
public:
- ModuleSVSHold(InspIRCd* Me) : Module(Me), cmd(this), s(Me)
+ ModuleSVSHold() : cmd(this)
{
ServerInstance->XLines->RegisterFactory(&s);
ServerInstance->AddCommand(&cmd);
CommandSwhois cmd;
public:
- ModuleSWhois(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleSWhois() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
Implementation eventlist[] = { I_OnWhoisLine, I_OnPostCommand };
{
if ((command != "OPER") || (result != CMD_SUCCESS))
return;
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
std::string swhois;
{
CommandTban cmd;
public:
- ModuleTimedBans(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleTimedBans()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
TimedBanList.clear();
{
CommandTline cmd;
public:
- ModuleTLine(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleTLine()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
public:
GenericCap cap;
- ModuleUHNames(InspIRCd* Me) : Module(Me), cap(this, "userhost-in-names")
+ ModuleUHNames() : cap(this, "userhost-in-names")
{
Implementation eventlist[] = { I_OnEvent, I_OnPreCommand, I_OnNamesListItem, I_On005Numeric };
ServerInstance->Modules->Attach(eventlist, this, 4);
public:
- ModuleUninvite(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleUninvite() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
{
CommandUserip cmd;
public:
- ModuleUserIP(InspIRCd* Me)
- : Module(Me), cmd(this)
+ ModuleUserIP()
+ : cmd(this)
{
ServerInstance->AddCommand(&cmd);
Implementation eventlist[] = { I_On005Numeric };
CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
{
- ConfigReader *Conf = new ConfigReader(ServerInstance);
+ ConfigReader *Conf = new ConfigReader;
for (int index = 0; index < Conf->Enumerate("vhost"); index++)
{
CommandVhost cmd;
public:
- ModuleVHost(InspIRCd* Me) : Module(Me), cmd(this)
+ ModuleVHost() : cmd(this)
{
ServerInstance->AddCommand(&cmd);
}
CommandSVSWatch sw;
public:
- Modulewatch(InspIRCd* Me)
- : Module(Me), maxwatch(32), cmdw(this, maxwatch), sw(this)
+ Modulewatch()
+ : maxwatch(32), cmdw(this, maxwatch), sw(this)
{
OnRehash(NULL);
whos_watching_me = new watchentries();
virtual void OnRehash(User* user)
{
- ConfigReader Conf(ServerInstance);
+ ConfigReader Conf;
maxwatch = Conf.ReadInteger("watch", "maxentries", 0, true);
if (!maxwatch)
maxwatch = 32;
bool reading_db; // If this is true, addlines are as a result of db reading, so don't bother flushing the db to disk.
// DO REMEMBER TO SET IT, otherwise it's annoying :P
public:
- ModuleXLineDB(InspIRCd* Me) : Module(Me)
- {
+ ModuleXLineDB() {
Implementation eventlist[] = { I_OnAddLine, I_OnDelLine, I_OnExpireLine };
ServerInstance->Modules->Attach(eventlist, this, 3);
void RehashHandler::Call(const std::string &reason)
{
- Server->SNO->WriteToSnoMask('a', "Rehashing config file %s %s",ServerConfig::CleanFilename(Server->ConfigFileName.c_str()), reason.c_str());
- Server->RehashUsersAndChans();
- FOREACH_MOD_I(Server, I_OnGarbageCollect, OnGarbageCollect());
- if (!Server->ConfigThread)
+ ServerInstance->SNO->WriteToSnoMask('a', "Rehashing config file %s %s",ServerConfig::CleanFilename(ServerInstance->ConfigFileName.c_str()), reason.c_str());
+ ServerInstance->RehashUsersAndChans();
+ FOREACH_MOD(I_OnGarbageCollect, OnGarbageCollect());
+ if (!ServerInstance->ConfigThread)
{
- Server->ConfigThread = new ConfigReaderThread(Server, "");
- Server->Threads->Start(Server->ConfigThread);
+ ServerInstance->ConfigThread = new ConfigReaderThread("");
+ ServerInstance->Threads->Start(ServerInstance->ConfigThread);
}
}
v << " CASEMAPPING=rfc1459 STATUSMSG=@" << (this->Config->AllowHalfop ? "%" : "") << "+ CHARSET=ascii TOPICLEN=" << Config->Limits.MaxTopic - 1 << " KICKLEN=" << Config->Limits.MaxKick - 1 << " MAXTARGETS=" << Config->MaxTargets - 1;
v << " AWAYLEN=" << Config->Limits.MaxAway - 1 << " CHANMODES=" << this->Modes->GiveModeList(MASK_CHANNEL) << " FNC NETWORK=" << Config->Network << " MAXPARA=32 ELIST=MU";
Config->data005 = v.str();
- FOREACH_MOD_I(this,I_On005Numeric,On005Numeric(Config->data005));
+ FOREACH_MOD(I_On005Numeric,On005Numeric(Config->data005));
Config->Update005();
}
#include <stdarg.h>
#include "snomasks.h"
-SnomaskManager::SnomaskManager(InspIRCd* Instance) : ServerInstance(Instance)
+SnomaskManager::SnomaskManager()
{
SnoMasks.clear();
this->SetupDefaults();
{
if (SnoMasks.find(letter) == SnoMasks.end())
{
- Snomask *s = new Snomask(ServerInstance, letter, type);
+ Snomask *s = new Snomask(letter, type);
SnoMasks[letter] = s;
return true;
}
char mysnomask = MySnomask;
ServerInstance->Logs->Log("snomask", DEFAULT, "%s: %s", desc.c_str(), message.c_str());
- FIRST_MOD_RESULT(ServerInstance, OnSendSnotice, MOD_RESULT, (mysnomask, desc, message));
+ FIRST_MOD_RESULT(OnSendSnotice, MOD_RESULT, (mysnomask, desc, message));
LastBlocked = (MOD_RESULT == MOD_RES_DENY);
}
if (!skip)
{
- ClientListenSocket *ll = new ClientListenSocket(this, portno, Addr);
+ ClientListenSocket *ll = new ClientListenSocket(portno, Addr);
if (ll->GetFd() > -1)
{
bound++;
}
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(this, OnStats, MOD_RESULT, (statschar, user, results));
+ FIRST_MOD_RESULT(OnStats, MOD_RESULT, (statschar, user, results));
if (MOD_RESULT == MOD_RES_DENY)
{
results.push_back(sn+" 219 "+user->nick+" "+statschar+" :End of /STATS report");
}
};
-TestSuite::TestSuite(InspIRCd* Instance) : ServerInstance(Instance)
+TestSuite::TestSuite()
{
cout << "\n\n*** STARTING TESTSUITE ***\n";
case '2':
cout << "Enter module filename to load: ";
cin >> modname;
- cout << (Instance->Modules->Load(modname.c_str()) ? "\nSUCCESS!\n" : "\nFAILURE\n");
+ cout << (ServerInstance->Modules->Load(modname.c_str()) ? "\nSUCCESS!\n" : "\nFAILURE\n");
break;
case '3':
cout << "Enter module filename to unload: ";
cin >> modname;
- cout << (Instance->Modules->Unload(modname.c_str()) ? "\nSUCCESS!\n" : "\nFAILURE\n");
+ cout << (ServerInstance->Modules->Unload(modname.c_str()) ? "\nSUCCESS!\n" : "\nFAILURE\n");
break;
case '4':
cout << (DoThreadTests() ? "\nSUCCESS!\n" : "\nFAILURE\n");
cout << "Creating new ThreadEngine class...\n";
try
{
- te = new ThreadEngine(ServerInstance);
+ te = new ThreadEngine;
}
catch (...)
{
#include <signal.h>
#include <fcntl.h>
-ThreadEngine::ThreadEngine(InspIRCd* Instance)
+ThreadEngine::ThreadEngine()
{
}
}
};
-SocketThread::SocketThread(InspIRCd* SI)
+SocketThread::SocketThread()
{
int fd = eventfd(0, O_NONBLOCK);
if (fd < 0)
}
};
-SocketThread::SocketThread(InspIRCd* SI)
+SocketThread::SocketThread()
{
int fds[2];
if (pipe(fds))
#include "inspircd.h"
#include "threadengines/threadengine_win32.h"
-ThreadEngine::ThreadEngine(InspIRCd* Instance)
+ThreadEngine::ThreadEngine()
{
}
}
};
-SocketThread::SocketThread(InspIRCd* SI)
+SocketThread::SocketThread()
{
int listenFD = socket(AF_INET, SOCK_STREAM, 0);
if (listenFD == -1)
#include "inspircd.h"
#include "timer.h"
-TimerManager::TimerManager(InspIRCd* Instance) : ServerInstance(Instance)
+TimerManager::TimerManager()
{
}
/* $Core */
#include "inspircd.h"
-UserResolver::UserResolver(InspIRCd* Instance, User* user, std::string to_resolve, QueryType qt, bool &cache) :
- Resolver(Instance, to_resolve, qt, cache), bound_user(user)
+UserResolver::UserResolver(User* user, std::string to_resolve, QueryType qt, bool &cache) :
+ Resolver(to_resolve, qt, cache), bound_user(user)
{
this->fwd = (qt == DNS_QUERY_A || qt == DNS_QUERY_AAAA);
this->bound_fd = user->GetFd();
if (this->bound_user->client_sa.sa.sa_family == AF_INET6)
{
/* IPV6 forward lookup */
- res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_AAAA, lcached);
+ res_forward = new UserResolver(bound_user, result, DNS_QUERY_AAAA, lcached);
}
else
{
/* IPV4 lookup */
- res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_A, lcached);
+ res_forward = new UserResolver(bound_user, result, DNS_QUERY_A, lcached);
}
- this->ServerInstance->AddResolver(res_forward, lcached);
+ ServerInstance->AddResolver(res_forward, lcached);
}
}
catch (CoreException& e)
#include "bancache.h"
/* add a client connection to the sockets list */
-void UserManager::AddUser(InspIRCd* Instance, int socket, ClientListenSocket* via, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server)
+void UserManager::AddUser(int socket, ClientListenSocket* via, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server)
{
/* NOTE: Calling this one parameter constructor for User automatically
* allocates a new UUID and places it in the hash_map.
User* New = NULL;
try
{
- New = new User(Instance);
+ New = new User();
}
catch (...)
{
- Instance->Logs->Log("USERS", DEFAULT,"*** WTF *** Duplicated UUID! -- Crack smoking monkies have been unleashed.");
- Instance->SNO->WriteToSnoMask('a', "WARNING *** Duplicate UUID allocated!");
+ ServerInstance->Logs->Log("USERS", DEFAULT,"*** WTF *** Duplicated UUID! -- Crack smoking monkies have been unleashed.");
+ ServerInstance->SNO->WriteToSnoMask('a', "WARNING *** Duplicate UUID allocated!");
return;
}
memcpy(&New->server_sa, server, sizeof(irc::sockets::sockaddrs));
/* Give each of the modules an attempt to hook the user for I/O */
- FOREACH_MOD_I(Instance, I_OnHookIO, OnHookIO(New, via));
+ FOREACH_MOD(I_OnHookIO, OnHookIO(New, via));
if (New->GetIOHook())
{
}
}
- Instance->Logs->Log("USERS", DEBUG,"New user fd: %d", socket);
+ ServerInstance->Logs->Log("USERS", DEBUG,"New user fd: %d", socket);
this->unregistered_count++;
/* The users default nick is their UUID */
New->nick.assign(New->uuid, 0, ServerInstance->Config->Limits.NickMax);
- New->server = Instance->FindServerNamePtr(Instance->Config->ServerName);
+ New->server = ServerInstance->FindServerNamePtr(ServerInstance->Config->ServerName);
New->ident.assign("unknown");
New->registered = REG_NONE;
- New->signon = Instance->Time() + Instance->Config->dns_timeout;
+ New->signon = ServerInstance->Time() + ServerInstance->Config->dns_timeout;
New->lastping = 1;
/* Smarter than your average bear^H^H^H^Hset of strlcpys. */
New->dhost.assign(New->GetIPString(), 0, 64);
New->host.assign(New->GetIPString(), 0, 64);
- Instance->Users->AddLocalClone(New);
- Instance->Users->AddGlobalClone(New);
+ ServerInstance->Users->AddLocalClone(New);
+ ServerInstance->Users->AddGlobalClone(New);
/*
* First class check. We do this again in FullConnect after DNS is done, and NICK/USER is recieved.
this->local_users.push_back(New);
- if ((this->local_users.size() > Instance->Config->SoftLimit) || (this->local_users.size() >= (unsigned int)Instance->SE->GetMaxFds()))
+ if ((this->local_users.size() > ServerInstance->Config->SoftLimit) || (this->local_users.size() >= (unsigned int)ServerInstance->SE->GetMaxFds()))
{
- Instance->SNO->WriteToSnoMask('a', "Warning: softlimit value has been reached: %d clients", Instance->Config->SoftLimit);
+ ServerInstance->SNO->WriteToSnoMask('a', "Warning: softlimit value has been reached: %d clients", ServerInstance->Config->SoftLimit);
this->QuitUser(New,"No more connections allowed");
return;
}
* besides that, if we get a positive bancache hit, we still won't fuck
* them over if they are exempt. -- w00t
*/
- New->exempt = (Instance->XLines->MatchesLine("E",New) != NULL);
+ New->exempt = (ServerInstance->XLines->MatchesLine("E",New) != NULL);
- if (BanCacheHit *b = Instance->BanCache->GetHit(New->GetIPString()))
+ if (BanCacheHit *b = ServerInstance->BanCache->GetHit(New->GetIPString()))
{
if (!b->Type.empty() && !New->exempt)
{
/* user banned */
- Instance->Logs->Log("BANCACHE", DEBUG, std::string("BanCache: Positive hit for ") + New->GetIPString());
- if (*Instance->Config->MoronBanner)
- New->WriteServ("NOTICE %s :*** %s", New->nick.c_str(), Instance->Config->MoronBanner);
+ ServerInstance->Logs->Log("BANCACHE", DEBUG, std::string("BanCache: Positive hit for ") + New->GetIPString());
+ if (*ServerInstance->Config->MoronBanner)
+ New->WriteServ("NOTICE %s :*** %s", New->nick.c_str(), ServerInstance->Config->MoronBanner);
this->QuitUser(New, b->Reason);
return;
}
else
{
- Instance->Logs->Log("BANCACHE", DEBUG, std::string("BanCache: Negative hit for ") + New->GetIPString());
+ ServerInstance->Logs->Log("BANCACHE", DEBUG, std::string("BanCache: Negative hit for ") + New->GetIPString());
}
}
else
{
if (!New->exempt)
{
- XLine* r = Instance->XLines->MatchesLine("Z",New);
+ XLine* r = ServerInstance->XLines->MatchesLine("Z",New);
if (r)
{
}
}
- if (!Instance->SE->AddFd(New, FD_WANT_FAST_READ | FD_WANT_EDGE_WRITE))
+ if (!ServerInstance->SE->AddFd(New, FD_WANT_FAST_READ | FD_WANT_EDGE_WRITE))
{
- Instance->Logs->Log("USERS", DEBUG,"Internal error on new connection");
+ ServerInstance->Logs->Log("USERS", DEBUG,"Internal error on new connection");
this->QuitUser(New, "Internal error handling connection");
}
*/
New->WriteServ("NOTICE Auth :*** Looking up your hostname...");
- if (Instance->Config->NoUserDns)
+ if (ServerInstance->Config->NoUserDns)
{
New->WriteServ("NOTICE %s :*** Skipping host resolution (disabled by server administrator)", New->nick.c_str());
New->dns_done = true;
if (user->registered == REG_ALL)
{
- FOREACH_MOD_I(ServerInstance,I_OnUserQuit,OnUserQuit(user, reason, oper_reason));
+ FOREACH_MOD(I_OnUserQuit,OnUserQuit(user, reason, oper_reason));
user->PurgeEmptyChannels();
user->WriteCommonQuit(reason, oper_reason);
}
- FOREACH_MOD_I(ServerInstance,I_OnUserDisconnect,OnUserDisconnect(user));
+ FOREACH_MOD(I_OnUserDisconnect,OnUserDisconnect(user));
if (user->registered != REG_ALL)
if (ServerInstance->Users->unregistered_count)
/* return how many users have a given mode e.g. 'a' */
int UserManager::ModeCount(const char mode)
{
- ModeHandler* mh = this->ServerInstance->Modes->FindMode(mode, MODETYPE_USER);
+ ModeHandler* mh = ServerInstance->Modes->FindMode(mode, MODETYPE_USER);
if (mh)
return mh->GetCount();
void FloodQuitUserHandler::Call(User* current)
{
- Server->Logs->Log("USERS",DEFAULT,"Excess flood from: %s@%s", current->ident.c_str(), current->host.c_str());
- Server->SNO->WriteToSnoMask('f',"Excess flood from: %s%s%s@%s",
+ ServerInstance->Logs->Log("USERS",DEFAULT,"Excess flood from: %s@%s", current->ident.c_str(), current->host.c_str());
+ ServerInstance->SNO->WriteToSnoMask('f',"Excess flood from: %s%s%s@%s",
current->registered == REG_ALL ? current->nick.c_str() : "",
current->registered == REG_ALL ? "!" : "", current->ident.c_str(), current->host.c_str());
- Server->Users->QuitUser(current, "Excess flood");
+ ServerInstance->Users->QuitUser(current, "Excess flood");
if (current->registered != REG_ALL)
{
- ZLine* zl = new ZLine(Server, Server->Time(), 0, Server->Config->ServerName, "Flood from unregistered connection", current->GetIPString());
- if (Server->XLines->AddLine(zl,NULL))
- Server->XLines->ApplyLines();
+ ZLine* zl = new ZLine(ServerInstance->Time(), 0, ServerInstance->Config->ServerName, "Flood from unregistered connection", current->GetIPString());
+ if (ServerInstance->XLines->AddLine(zl,NULL))
+ ServerInstance->XLines->ApplyLines();
else
delete zl;
}
UserResolver *res_reverse;
QueryType resolvtype = this->client_sa.sa.sa_family == AF_INET6 ? DNS_QUERY_PTR6 : DNS_QUERY_PTR4;
- res_reverse = new UserResolver(ServerInstance, this, sip, resolvtype, cached);
+ res_reverse = new UserResolver(this, sip, resolvtype, cached);
ServerInstance->AddResolver(res_reverse, cached);
}
}
}
-User::User(InspIRCd* Instance, const std::string &uid)
+User::User(const std::string &uid)
{
- server = Instance->FindServerNamePtr(Instance->Config->ServerName);
+ server = ServerInstance->FindServerNamePtr(ServerInstance->Config->ServerName);
age = ServerInstance->Time();
Penalty = 0;
lastping = signon = idle_lastmsg = nping = registered = 0;
AllowedPrivs = AllowedOperCommands = NULL;
if (uid.empty())
- uuid.assign(Instance->GetUID(), 0, UUID_LENGTH - 1);
+ uuid.assign(ServerInstance->GetUID(), 0, UUID_LENGTH - 1);
else
uuid.assign(uid, 0, UUID_LENGTH - 1);
ServerInstance->Logs->Log("USERS", DEBUG,"New UUID for user: %s (%s)", uuid.c_str(), uid.empty() ? "allocated new" : "used remote");
- user_hash::iterator finduuid = Instance->Users->uuidlist->find(uuid);
- if (finduuid == Instance->Users->uuidlist->end())
- (*Instance->Users->uuidlist)[uuid] = this;
+ user_hash::iterator finduuid = ServerInstance->Users->uuidlist->find(uuid);
+ if (finduuid == ServerInstance->Users->uuidlist->end())
+ (*ServerInstance->Users->uuidlist)[uuid] = this;
else
throw CoreException("Duplicate UUID "+std::string(uuid)+" in User constructor");
}
ModResult MOD_RESULT;
std::string command("LUSERS");
std::vector<std::string> parameters;
- FIRST_MOD_RESULT(ServerInstance, OnPreCommand, MOD_RESULT, (command, parameters, this, true, "LUSERS"));
+ FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, parameters, this, true, "LUSERS"));
if (!MOD_RESULT)
ServerInstance->CallCommandHandler(command, parameters, this);
this->InvalidateCache();
NICKForced.set(this, 1);
- FIRST_MOD_RESULT(ServerInstance, OnUserPreNick, MOD_RESULT, (this, newnick));
+ FIRST_MOD_RESULT(OnUserPreNick, MOD_RESULT, (this, newnick));
NICKForced.set(this, 0);
if (MOD_RESULT == MOD_RES_DENY)
char textbuffer[MAXBUF];
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnNumeric, MOD_RESULT, (this, numeric, text));
+ FIRST_MOD_RESULT(OnNumeric, MOD_RESULT, (this, numeric, text));
if (MOD_RESULT == MOD_RES_DENY)
return;
if (IS_LOCAL(this))
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnChangeLocalUserGECOS, MOD_RESULT, (this,gecos));
+ FIRST_MOD_RESULT(OnChangeLocalUserGECOS, MOD_RESULT, (this,gecos));
if (MOD_RESULT == MOD_RES_DENY)
return false;
FOREACH_MOD(I_OnChangeName,OnChangeName(this,gecos));
char buffer[MAXBUF];
ModResult result = MOD_RES_PASSTHRU;
- FIRST_MOD_RESULT(ServerInstance, OnHostCycle, result, (this));
+ FIRST_MOD_RESULT(OnHostCycle, result, (this));
if (result == MOD_RES_DENY)
return;
if (IS_LOCAL(this))
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnChangeLocalUserHost, MOD_RESULT, (this,shost));
+ FIRST_MOD_RESULT(OnChangeLocalUserHost, MOD_RESULT, (this,shost));
if (MOD_RESULT == MOD_RES_DENY)
return false;
}
if (i2 != ServerInstance->chanlist->end())
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(ServerInstance, OnChannelPreDelete, MOD_RESULT, (i2->second));
+ FIRST_MOD_RESULT(OnChannelPreDelete, MOD_RESULT, (i2->second));
if (MOD_RESULT == MOD_RES_DENY)
continue; // delete halted by module
FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(i2->second));
}
}
- FOREACH_MOD_I(this, I_OnWhois,OnWhois(user,dest));
+ FOREACH_MOD(I_OnWhois,OnWhois(user,dest));
/*
* We only send these if we've been provided them. That is, if hidewhois is turned off, and user is local, or
}
}
- /*ELine* item = new ELine(ServerInstance, ServerInstance->Time(), duration, source, reason, ih.first.c_str(), ih.second.c_str());*/
+ /*ELine* item = new ELine(ServerInstance->Time(), duration, source, reason, ih.first.c_str(), ih.second.c_str());*/
XLineFactory* xlf = GetFactory(line->type);
if (!xlf)
return false;
}
-XLineManager::XLineManager(InspIRCd* Instance) : ServerInstance(Instance)
+XLineManager::XLineManager()
{
- GFact = new GLineFactory(Instance);
- EFact = new ELineFactory(Instance);
- KFact = new KLineFactory(Instance);
- QFact = new QLineFactory(Instance);
- ZFact = new ZLineFactory(Instance);
+ GFact = new GLineFactory;
+ EFact = new ELineFactory;
+ KFact = new KLineFactory;
+ QFact = new QLineFactory;
+ ZFact = new ZLineFactory;
RegisterFactory(GFact);
RegisterFactory(EFact);
#include <psapi.h>\r
\r
\r
-IPCThread::IPCThread(InspIRCd* Instance) : Thread(), ServerInstance(Instance)\r
+IPCThread::IPCThread()\r
{\r
if (!initwmi())\r
ServerInstance->Logs->Log("IPC", DEBUG, "Could not initialise WMI. CPU percantage reports will not be available.");\r
}\r
\r
\r
-IPC::IPC(InspIRCd* Srv) : ServerInstance(Srv)\r
+IPC::IPC()\r
{\r
/* The IPC pipe is threaded */\r
thread = new IPCThread(Srv);\r
#include "threadengine.h"
#include <windows.h>
-class InspIRCd;
-
class IPCThread : public Thread
{
BOOL Connected;
DWORD BytesRead;
BOOL Success;
HANDLE Pipe;
- InspIRCd* ServerInstance;
char status[MAXBUF];
int result;
public:
- IPCThread(InspIRCd* Instance);
+ IPCThread();
virtual ~IPCThread();
virtual void Run();
const char GetStatus();
class IPC
{
private:
- InspIRCd* ServerInstance;
IPCThread* thread;
public:
- IPC(InspIRCd* Srv);
+ IPC();
void Check();
~IPC();
};
-#endif
\ No newline at end of file
+#endif
/* Many inspircd classes contain function pointers/functors which can be changed to point at platform specific implementations
* of code. This function repoints these pointers and functors so that calls are windows specific.
*/
-void ChangeWindowsSpecificPointers(InspIRCd* Instance)
+void ChangeWindowsSpecificPointers()
{
Instance->Logs->Log("win32",DEBUG,"Changing to windows specific pointer and functor set");
}
-DWORD WindowsForkStart(InspIRCd* Instance)
+DWORD WindowsForkStart()
{
/* Windows implementation of fork() :P */
if (owner_processid)
return ExitCode;
}
-void WindowsForkKillOwner(InspIRCd * Instance)
+void WindowsForkKillOwner()
{
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, owner_processid);
if(!hProcess || !owner_processid)
void ::operator delete(void * ptr);
/* IPC Handlers */
-class InspIRCd;
class ValueItem;
class ServerConfig;
/* Clear a windows console */
CoreExport void ClearConsole();
-CoreExport DWORD WindowsForkStart(InspIRCd* Instance);
+CoreExport DWORD WindowsForkStart();
-CoreExport void WindowsForkKillOwner(InspIRCd* Instance);
+CoreExport void WindowsForkKillOwner();
-CoreExport void ChangeWindowsSpecificPointers(InspIRCd* Instance);
+CoreExport void ChangeWindowsSpecificPointers();
CoreExport bool ValidateWindowsDnsServer(ServerConfig* conf, const char* tag, const char* value, ValueItem &data);
projects / user / henk / code / inspircd.git / commitdiff