* +------------------------------------+
*
* InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- * E-mail:
- * <brain@chatspike.net>
- * <Craig@chatspike.net>
+ * E-mail:
+ * <brain@chatspike.net>
+ * <Craig@chatspike.net>
*
* Written by Craig Edwards, Craig McLure, and others.
* This program is free but copyrighted software; see
- * the file COPYING for details.
+ * the file COPYING for details.
*
* ---------------------------------------------------
*/
*/
enum DebugLevels { DEBUG, VERBOSE, DEFAULT, SPARSE, NONE };
-/** Used with OnExtendedMode() method of modules
- */
-enum ModeTargetType { MT_CHANNEL, MT_CLIENT, MT_SERVER };
-
/** Used with OnAccessCheck() method of modules
*/
enum AccessControlType {
#include <typeinfo>
#include "timer.h"
#include "mode.h"
+#include "dns.h"
class Server;
class ServerConfig;
* be loaded. If this happens, the error message returned by ModuleException::GetReason will be displayed to the user
* attempting to load the module, or dumped to the console if the ircd is currently loading for the first time.
*/
-class ModuleException
+class ModuleException : public classbase
{
private:
/** Holds the error message to be displayed
/** Implementation-specific flags which may be set in Module::Implements()
*/
enum Implementation { I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart, I_OnRehash, I_OnServerRaw,
- I_OnExtendedMode, I_OnUserPreJoin, I_OnUserPreKick, I_OnUserKick, I_OnOper, I_OnInfo, I_OnWhois, I_OnUserPreInvite,
+ I_OnUserPreJoin, I_OnUserPreKick, I_OnUserKick, I_OnOper, I_OnInfo, I_OnWhois, I_OnUserPreInvite,
I_OnUserInvite, I_OnUserPreMessage, I_OnUserPreNotice, I_OnUserPreNick, I_OnUserMessage, I_OnUserNotice, I_OnMode,
I_OnGetServerDescription, I_OnSyncUser, I_OnSyncChannel, I_OnSyncChannelMetaData, I_OnSyncUserMetaData,
I_OnDecodeMetaData, I_ProtoSendMode, I_ProtoSendMetaData, I_OnWallops, I_OnChangeHost, I_OnChangeName, I_OnAddGLine,
I_OnAddZLine, I_OnAddQLine, I_OnAddKLine, I_OnAddELine, I_OnDelGLine, I_OnDelZLine, I_OnDelKLine, I_OnDelELine, I_OnDelQLine,
I_OnCleanup, I_OnUserPostNick, I_OnAccessCheck, I_On005Numeric, I_OnKill, I_OnRemoteKill, I_OnLoadModule, I_OnUnloadModule,
- I_OnBackgroundTimer, I_OnSendList, I_OnPreCommand, I_OnCheckReady, I_OnUserRrgister, I_OnRawMode, I_OnCheckInvite,
+ I_OnBackgroundTimer, I_OnPreCommand, I_OnCheckReady, I_OnUserRrgister, I_OnRawMode, I_OnCheckInvite,
I_OnCheckKey, I_OnCheckLimit, I_OnCheckBan, I_OnStats, I_OnChangeLocalUserHost, I_OnChangeLocalUserGecos, I_OnLocalTopicChange,
I_OnPostLocalTopicChange, I_OnEvent, I_OnRequest, I_OnOperCompre, I_OnGlobalOper, I_OnGlobalConnect, I_OnAddBan, I_OnDelBan,
I_OnRawSocketAccept, I_OnRawSocketClose, I_OnRawSocketWrite, I_OnRawSocketRead, I_OnChangeLocalUserGECOS, I_OnUserRegister,
* its methods will be called when irc server events occur. class inherited from module must be
* instantiated by the ModuleFactory class (see relevent section) for the module to be initialised.
*/
-class Module : public classbase
+class Module : public Extensible
{
public:
*/
virtual void OnServerRaw(std::string &raw, bool inbound, userrec* user);
- /** Called whenever an extended mode is to be processed.
- * The type parameter is MT_SERVER, MT_CLIENT or MT_CHANNEL, dependent on where the mode is being
- * changed. mode_on is set when the mode is being set, in which case params contains a list of
- * parameters for the mode as strings. If mode_on is false, the mode is being removed, and parameters
- * may contain the parameters for the mode, dependent on wether they were defined when a mode handler
- * was set up with Server::AddExtendedMode
- * If the mode is a channel mode, target is a chanrec*, and if it is a user mode, target is a userrec*.
- * You must cast this value yourself to make use of it.
- * @param user The user issuing the mode
- * @param target The user or channel having the mode set on them
- * @param modechar The mode character being set
- * @param type The type of 4mode (user or channel) being set
- * @param mode_on True if the mode is being set, false if it is being unset
- * @param params A list of parameters for any channel mode (currently supports either 0 or 1 parameters)
- */
- virtual int OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms);
-
/** Called whenever a user is about to join a channel, before any processing is done.
* Returning a value of 1 from this function stops the process immediately, causing no
* output to be sent to the user by the core. If you do this you must produce your own numerics,
virtual int OnUserPreJoin(userrec* user, chanrec* chan, const char* cname);
/** Called whenever a user is about to be kicked.
- * Returning a value of 1 from this function stops the process immediately, causing no
- * output to be sent to the user by the core. If you do this you must produce your own numerics,
- * notices etc.
+ * Returning a value of 1 from this function stops the process immediately, causing no
+ * output to be sent to the user by the core. If you do this you must produce your own numerics,
+ * notices etc.
* @param source The user issuing the kick
* @param user The user being kicked
* @param chan The channel the user is being kicked from
* @param reason The kick reason
* @return 1 to prevent the kick, 0 to continue normally, -1 to explicitly allow the kick regardless of normal operation
- */
+ */
virtual int OnUserPreKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason);
/** Called whenever a user is kicked.
/** Called whenever a zline is added by a local user.
* This method is triggered after the line is added.
- * @param duration The duration of the line in seconds
- * @param source The sender of the line
- * @param reason The reason text to be displayed
- * @param ipmask The hostmask to add
+ * @param duration The duration of the line in seconds
+ * @param source The sender of the line
+ * @param reason The reason text to be displayed
+ * @param ipmask The hostmask to add
*/
virtual void OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask);
/** Called whenever a kline is added by a local user.
* This method is triggered after the line is added.
- * @param duration The duration of the line in seconds
- * @param source The sender of the line
- * @param reason The reason text to be displayed
- * @param hostmask The hostmask to add
+ * @param duration The duration of the line in seconds
+ * @param source The sender of the line
+ * @param reason The reason text to be displayed
+ * @param hostmask The hostmask to add
*/
virtual void OnAddKLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask);
/** Called whenever a qline is added by a local user.
* This method is triggered after the line is added.
- * @param duration The duration of the line in seconds
- * @param source The sender of the line
- * @param reason The reason text to be displayed
- * @param nickmask The hostmask to add
+ * @param duration The duration of the line in seconds
+ * @param source The sender of the line
+ * @param reason The reason text to be displayed
+ * @param nickmask The hostmask to add
*/
virtual void OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask);
/** Called whenever a eline is added by a local user.
* This method is triggered after the line is added.
- * @param duration The duration of the line in seconds
- * @param source The sender of the line
- * @param reason The reason text to be displayed
- * @param hostmask The hostmask to add
+ * @param duration The duration of the line in seconds
+ * @param source The sender of the line
+ * @param reason The reason text to be displayed
+ * @param hostmask The hostmask to add
*/
virtual void OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask);
/** Called whenever a gline is deleted.
* This method is triggered after the line is deleted.
- * @param source The user removing the line
- * @param hostmask The hostmask to delete
+ * @param source The user removing the line
+ * @param hostmask The hostmask to delete
*/
virtual void OnDelGLine(userrec* source, const std::string &hostmask);
/** Called whenever a zline is deleted.
* This method is triggered after the line is deleted.
- * @param source The user removing the line
- * @param hostmask The hostmask to delete
+ * @param source The user removing the line
+ * @param hostmask The hostmask to delete
*/
virtual void OnDelZLine(userrec* source, const std::string &ipmask);
/** Called whenever a kline is deleted.
* This method is triggered after the line is deleted.
- * @param source The user removing the line
- * @param hostmask The hostmask to delete
+ * @param source The user removing the line
+ * @param hostmask The hostmask to delete
*/
virtual void OnDelKLine(userrec* source, const std::string &hostmask);
/** Called whenever a qline is deleted.
* This method is triggered after the line is deleted.
- * @param source The user removing the line
- * @param hostmask The hostmask to delete
+ * @param source The user removing the line
+ * @param hostmask The hostmask to delete
*/
virtual void OnDelQLine(userrec* source, const std::string &nickmask);
/** Called whenever a eline is deleted.
* This method is triggered after the line is deleted.
- * @param source The user removing the line
- * @param hostmask The hostmask to delete
+ * @param source The user removing the line
+ * @param hostmask The hostmask to delete
*/
virtual void OnDelELine(userrec* source, const std::string &hostmask);
/** Called after any nickchange, local or remote. This can be used to track users after nickchanges
* have been applied. Please note that although you can see remote nickchanges through this function, you should
- * NOT make any changes to the userrec if the user is a remote user as this may cause a desnyc.
- * check user->server before taking any action (including returning nonzero from the method).
+ * NOT make any changes to the userrec if the user is a remote user as this may cause a desnyc.
+ * check user->server before taking any action (including returning nonzero from the method).
* Because this method is called after the nickchange is taken place, no return values are possible
* to indicate forbidding of the nick change. Use OnUserPreNick for this.
* @param user The user changing their nick
* @param oldnick The old nickname of the user before the nickchange
- */
+ */
virtual void OnUserPostNick(userrec* user, const std::string &oldnick);
/** Called before an action which requires a channel privilage check.
virtual void OnLoadModule(Module* mod,const std::string &name);
/** Called whenever a module is unloaded.
- * mod will contain a pointer to the module, and string will contain its name,
- * for example m_widgets.so. This function is primary for dependency checking,
- * your module may decide to enable some extra features if it sees that you have
- * for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly
- * recommended that modules do *NOT* bail if they cannot satisfy dependencies,
- * but instead operate under reduced functionality, unless the dependency is
- * absolutely neccessary (e.g. a module that extends the features of another
- * module).
+ * mod will contain a pointer to the module, and string will contain its name,
+ * for example m_widgets.so. This function is primary for dependency checking,
+ * your module may decide to enable some extra features if it sees that you have
+ * for example loaded "m_killwidgets.so" with "m_makewidgets.so". It is highly
+ * recommended that modules do *NOT* bail if they cannot satisfy dependencies,
+ * but instead operate under reduced functionality, unless the dependency is
+ * absolutely neccessary (e.g. a module that extends the features of another
+ * module).
* @param mod Pointer to the module being unloaded (still valid)
* @param name The filename of the module being unloaded
- */
+ */
virtual void OnUnloadModule(Module* mod,const std::string &name);
/** Called once every five seconds for background processing.
*/
virtual void OnBackgroundTimer(time_t curtime);
- /** Called whenever a list is needed for a listmode.
- * For example, when a /MODE #channel +b (without any other parameters) is called,
- * if a module was handling +b this function would be called. The function can then
- * output any lists it wishes to. Please note that all modules will see all mode
- * characters to provide the ability to extend each other, so please only output
- * a list if the mode character given matches the one(s) you want to handle.
- * @param user The user requesting the list
- * @param channel The channel the list is for
- * @param mode The listmode which a list is being requested on
- */
- virtual void OnSendList(userrec* user, chanrec* channel, char mode);
-
/** Called whenever any command is about to be executed.
* This event occurs for all registered commands, wether they are registered in the core,
* or another module, but it will not occur for invalid commands (e.g. ones which do not
* @param validated True if the command has passed all checks, e.g. it is recognised, has enough parameters, the user has permission to execute it, etc.
* @return 1 to block the command, 0 to allow
*/
- virtual int OnPreCommand(const std::string &command, char **parameters, int pcnt, userrec *user, bool validated);
+ virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated);
/** Called to check if a user who is connecting can now be allowed to register
* If any modules return false for this function, the user is held in the waiting
virtual int OnCheckInvite(userrec* user, chanrec* chan);
/** Called whenever a user joins a channel, to determine if key checks should go ahead or not.
- * This method will always be called for each join, wether or not the channel is actually +k, and
- * determines the outcome of an if statement around the whole section of key checking code.
+ * This method will always be called for each join, wether or not the channel is actually +k, and
+ * determines the outcome of an if statement around the whole section of key checking code.
* if the user specified no key, the keygiven string will be a valid but empty value.
- * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+ * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
* @param user The user joining the channel
* @param chan The channel being joined
* @return 1 to explicitly allow the join, 0 to proceed as normal
- */
+ */
virtual int OnCheckKey(userrec* user, chanrec* chan, const std::string &keygiven);
/** Called whenever a user joins a channel, to determine if channel limit checks should go ahead or not.
- * This method will always be called for each join, wether or not the channel is actually +l, and
- * determines the outcome of an if statement around the whole section of channel limit checking code.
- * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+ * This method will always be called for each join, wether or not the channel is actually +l, and
+ * determines the outcome of an if statement around the whole section of channel limit checking code.
+ * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
* @param user The user joining the channel
* @param chan The channel being joined
* @return 1 to explicitly allow the join, 0 to proceed as normal
- */
+ */
virtual int OnCheckLimit(userrec* user, chanrec* chan);
/** Called whenever a user joins a channel, to determine if banlist checks should go ahead or not.
- * This method will always be called for each join, wether or not the user actually matches a channel ban, and
- * determines the outcome of an if statement around the whole section of ban checking code.
- * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+ * This method will always be called for each join, wether or not the user actually matches a channel ban, and
+ * determines the outcome of an if statement around the whole section of ban checking code.
+ * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
* @param user The user joining the channel
* @param chan The channel being joined
* @return 1 to explicitly allow the join, 0 to proceed as normal
- */
+ */
virtual int OnCheckBan(userrec* user, chanrec* chan);
/** Called on all /STATS commands
* output to users and other servers. All modules should instantiate at least one copy of this class,
* and use its member functions to perform their tasks.
*/
-class Server : public classbase
+class Server : public Extensible
{
public:
/** Default constructor.
*/
Module* FindFeature(const std::string &FeatureName);
+ const std::string& GetModuleName(Module* m);
+
/** Writes a log string.
* This method writes a line of text to the log. If the level given is lower than the
* level given in the configuration, this command has no effect.
virtual bool AddMode(ModeHandler* mh, const unsigned char modechar);
+ virtual bool AddModeWatcher(ModeWatcher* mw);
+
+ virtual bool DelModeWatcher(ModeWatcher* mw);
+
+ virtual bool AddResolver(Resolver* r);
+
/** Adds a command to the command table.
* This allows modules to add extra commands into the command table. You must place a function within your
* module which is is of type handlerfunc:
* your server in an unstable state!
*/
- virtual void SendMode(char **parameters, int pcnt, userrec *user);
+ virtual void SendMode(const char **parameters, int pcnt, userrec *user);
/** Sends to all users matching a mode mask
* You must specify one or more usermodes as the first parameter. These can be RFC specified modes such as +i,
* used for privilage checks, etc.
* @return True if the command exists
*/
- virtual bool CallCommandHandler(const std::string &commandname, char** parameters, int pcnt, userrec* user);
+ virtual bool CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, userrec* user);
/** This function returns true if the commandname exists, pcnt is equal to or greater than the number
* of paramters the command requires, the user specified is allowed to execute the command, AND
/** The file contents
*/
file_cache fc;
+
+ unsigned long contentsize;
+
+ void CalcSize();
+
public:
- /** Default constructor.
- * This method does not load any file into memory, you must use the LoadFile method
- * after constructing the class this way.
- */
- 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(const std::string &filename);
-
- /** Default destructor.
- * This deletes the memory allocated to the file.
- */
- ~FileReader();
-
- /** Used to load a file.
- * This method loads a file into the class ready for GetLine and
- * and other methods to be called. If the file could not be loaded, FileReader::FileSize
- * returns 0.
- */
- void LoadFile(const std::string &filename);
-
- /** Returns true if the file exists
- * This function will return false if the file could not be opened.
- */
- bool Exists();
-
- /** Retrieve one line from the file.
- * This method retrieves one line from the text file. If an empty non-NULL string is returned,
- * the index was out of bounds, or the line had no data on it.
- */
- std::string GetLine(int x);
-
- /** Returns the size of the file in lines.
- * This method returns the number of lines in the read file. If it is 0, no lines have been
- * read into memory, either because the file is empty or it does not exist, or cannot be
- * opened due to permission problems.
- */
- int FileSize();
+ /** Default constructor.
+ * This method does not load any file into memory, you must use the LoadFile method
+ * after constructing the class this way.
+ */
+ 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(const std::string &filename);
+
+ /** Default destructor.
+ * This deletes the memory allocated to the file.
+ */
+ ~FileReader();
+
+ /** Used to load a file.
+ * This method loads a file into the class ready for GetLine and
+ * and other methods to be called. If the file could not be loaded, FileReader::FileSize
+ * returns 0.
+ */
+ void LoadFile(const std::string &filename);
+
+ /** Returns the whole content of the file as std::string
+ */
+ std::string Contents();
+
+ /** Returns the entire size of the file as std::string
+ */
+ unsigned long ContentSize();
+
+ /** Returns true if the file exists
+ * This function will return false if the file could not be opened.
+ */
+ bool Exists();
+
+ /** Retrieve one line from the file.
+ * This method retrieves one line from the text file. If an empty non-NULL string is returned,
+ * the index was out of bounds, or the line had no data on it.
+ */
+ std::string GetLine(int x);
+
+ /** Returns the size of the file in lines.
+ * This method returns the number of lines in the read file. If it is 0, no lines have been
+ * read into memory, either because the file is empty or it does not exist, or cannot be
+ * opened due to permission problems.
+ */
+ int FileSize();
};