* +------------------------------------+
*
* 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 "dynamic.h"
#include "base.h"
#include "ctables.h"
-#include "socket.h"
+#include "inspsocket.h"
#include <string>
#include <deque>
#include <sstream>
#include <typeinfo>
#include "timer.h"
+#include "mode.h"
class Server;
class ServerConfig;
+// Forward-delacare module for ModuleMessage etc
+class Module;
+
/** Low level definition of a FileReader classes file cache area
*/
typedef std::deque<std::string> file_cache;
typedef std::deque<userrec*> chanuserlist;
+/** Holds a list of 'published features' for modules.
+ */
+typedef std::map<std::string,Module*> featurelist;
+
/**
* This #define allows us to call a method in all
* loaded modules in a readable simple way, e.g.:
} \
catch (ModuleException& modexcept) \
{ \
- log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
+ log(DEBUG,"Module exception caught: %s",modexcept.GetReason()); \
} \
} \
}
// useful macros
-#define IS_LOCAL(x) (x->fd > -1)
+#define IS_LOCAL(x) ((x->fd > -1) && (x->fd <= MAX_DESCRIPTORS))
#define IS_REMOTE(x) (x->fd < 0)
#define IS_MODULE_CREATED(x) (x->fd == FD_MAGIC_NUMBER)
Admin(std::string name, std::string email, std::string nick);
};
-// Forward-delacare module for ModuleMessage etc
-class Module;
-
/** The ModuleMessage class is the base class of Request and Event
* This class is used to represent a basic data structure which is passed
* between modules for safe inter-module communications.
char* Send();
};
-/** Holds an extended mode's details.
- * Used internally by modules.cpp
- */
-class ExtMode : public classbase
-{
- public:
- char modechar;
- int type;
- bool needsoper;
- int params_when_on;
- int params_when_off;
- bool list;
- ExtMode(char mc, int ty, bool oper, int p_on, int p_off) : modechar(mc), type(ty), needsoper(oper), params_when_on(p_on), params_when_off(p_off), list(false) { };
-};
-
-
/** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
* When a module whishes to abort, e.g. within a constructor, it should throw an exception using ModuleException or
* a class derived from ModuleException. If a module throws an exception during its constructor, the module will not
* 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 mode (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.
* AC_DEVOICE (4) - a user is being devoiced<br>
* AC_HALFOP (5) - a user is being halfopped<br>
* AC_DEHALFOP (6) - a user is being dehalfopped<br>
- * AC_INVITE (7) - a user is being invited<br>
+ * AC_INVITE () - a user is being invited<br>
* AC_GENERAL_MODE (8) - a user channel mode is being changed<br><br>
* Upon returning from your function you must return either ACR_DEFAULT, to indicate the module wishes
* to do nothing, or ACR_DENY where approprate to deny the action, and ACR_ALLOW where appropriate to allow
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
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.
*/
std::string GetVersion();
+ /** Publish a 'feature'.
+ * There are two ways for a module to find another module it depends on.
+ * Either by name, using Server::FindModule, or by feature, using this
+ * function. A feature is an arbitary string which identifies something this
+ * module can do. For example, if your module provides SSL support, but other
+ * modules provide SSL support too, all the modules supporting SSL should
+ * publish an identical 'SSL' feature. This way, any module requiring use
+ * of SSL functions can just look up the 'SSL' feature using FindFeature,
+ * then use the module pointer they are given.
+ * @param FeatureName The case sensitive feature name to make available
+ * @param Mod a pointer to your module class
+ * @returns True on success, false if the feature is already published by
+ * another module.
+ */
+ bool PublishFeature(const std::string &FeatureName, Module* Mod);
+
+ /** Unpublish a 'feature'.
+ * When your module exits, it must call this method for every feature it
+ * is providing so that the feature table is cleaned up.
+ * @param FeatureName the feature to remove
+ */
+ bool UnpublishFeature(const std::string &FeatureName);
+
+ /** Find a 'feature'.
+ * There are two ways for a module to find another module it depends on.
+ * Either by name, using Server::FindModule, or by feature, using the
+ * Server::PublishFeature method. A feature is an arbitary string which
+ * identifies something this module can do. For example, if your module
+ * provides SSL support, but other modules provide SSL support too, all
+ * the modules supporting SSL should publish an identical 'SSL' feature.
+ * To find a module capable of providing the feature you want, simply
+ * call this method with the feature name you are looking for.
+ * @param FeatureName The feature name you wish to obtain the module for
+ * @returns A pointer to a valid module class on success, NULL on failure.
+ */
+ 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 Admin GetAdmin();
- /** Adds an extended mode letter which is parsed by a module.
- * This allows modules to add extra mode letters, e.g. +x for hostcloak.
- * the "type" parameter is either MT_CHANNEL, MT_CLIENT, or MT_SERVER, to
- * indicate wether the mode is a channel mode, a client mode, or a server mode.
- * requires_oper is used with MT_CLIENT type modes only to indicate the mode can only
- * be set or unset by an oper. If this is used for MT_CHANNEL type modes it is ignored.
- * params_when_on is the number of modes to expect when the mode is turned on
- * (for type MT_CHANNEL only), e.g. with mode +k, this would have a value of 1.
- * the params_when_off value has a similar value to params_when_on, except it indicates
- * the number of parameters to expect when the mode is disabled. Modes which act in a similar
- * way to channel mode +l (e.g. require a parameter to enable, but not to disable) should
- * use this parameter. The function returns false if the mode is unavailable, and will not
- * attempt to allocate another character, as this will confuse users. This also means that
- * as only one module can claim a specific mode character, the core does not need to keep track
- * of which modules own which modes, which speeds up operation of the server. In this version,
- * a mode can have at most one parameter, attempting to use more parameters will have undefined
- * effects.
- */
- virtual bool AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off);
-
- /** Adds an extended mode letter which is parsed by a module and handled in a list fashion.
- * This call is used to implement modes like +q and +a. The characteristics of these modes are
- * as follows:
- *
- * (1) They are ALWAYS on channels, not on users, therefore their type is MT_CHANNEL
- *
- * (2) They always take exactly one parameter when being added or removed
- *
- * (3) They can be set multiple times, usually on users in channels
- *
- * (4) The mode and its parameter are NOT stored in the channels modes structure
- *
- * It is down to the module handling the mode to maintain state and determine what 'items' (e.g. users,
- * or a banlist) have the mode set on them, and process the modes at the correct times, e.g. during access
- * checks on channels, etc. When the extended mode is triggered the OnExtendedMode method will be triggered
- * as above. Note that the target you are given will be a channel, if for example your mode is set 'on a user'
- * (in for example +a) you must use Server::Find to locate the user the mode is operating on.
- * Your mode handler may return 1 to handle the mode AND tell the core to display the mode change, e.g.
- * '+aaa one two three' in the case of the mode for 'two', or it may return -1 to 'eat' the mode change,
- * so the above example would become '+aa one three' after processing.
- */
- virtual bool AddExtendedListMode(char modechar);
+ virtual bool AddMode(ModeHandler* mh, const unsigned char modechar);
+
+ virtual bool AddModeWatcher(ModeWatcher* mw);
+
+ virtual bool DelModeWatcher(ModeWatcher* mw);
/** 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
/** 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();
};
typedef DLLFactory<ModuleFactory> ircd_module;
-
-bool ModeDefined(char c, int i);
-bool ModeDefinedOper(char c, int i);
-int ModeDefinedOn(char c, int i);
-int ModeDefinedOff(char c, int i);
-void ModeMakeList(char modechar);
-bool ModeIsListMode(char modechar, int type);
+typedef std::vector<Module*> ModuleList;
+typedef std::vector<ircd_module*> FactoryList;
#endif
projects / user / henk / code / inspircd.git / blobdiff