/** Removes a command if the sources match. Used as a helper for
* safe hash_map delete while iter in RemoveCommands(const char* source).
*/
- void RemoveCommand(nspace::hash_map<std::string,Command*>::iterator safei, const char* source);
+ void RemoveCommand(nspace::hash_map<std::string,Command*>::iterator safei, Module* source);
public:
void DoLines(User* current, bool one_only = false);
/** Remove all commands relating to module 'source'.
- * @param source A module name which has introduced new commands
+ * @param source A module which has introduced new commands
*/
- void RemoveCommands(const char* source);
+ void RemoveCommands(Module* source);
/** Remove all core commands and unload their shared objects
*/
public:
/** Standard constructor
*/
- CommandReload (InspIRCd* Instance) : Command(Instance,"RELOAD","o",1) { syntax = "<core-command>"; }
+ CommandReload (InspIRCd* Instance) : Command(Instance,NULL,"RELOAD","o",1) { syntax = "<core-command>"; }
/** Handle RELOAD
*/
CmdResult Handle(const std::vector<std::string>& parameters, User *user);
public:
/** Constructor for admin.
*/
- CommandAdmin (InspIRCd* Instance) : Command(Instance,"ADMIN",0,0) { syntax = "[<servername>]"; }
+ CommandAdmin (InspIRCd* Instance) : Command(Instance,NULL,"ADMIN",0,0) { syntax = "[<servername>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for away.
*/
- CommandAway (InspIRCd* Instance) : Command(Instance,"AWAY",0,0) { syntax = "[<message>]"; }
+ CommandAway (InspIRCd* Instance) : Command(Instance,NULL,"AWAY",0,0) { syntax = "[<message>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for clearcache.
*/
- CommandClearcache (InspIRCd* Instance) : Command(Instance,"CLEARCACHE","o",0) { }
+ CommandClearcache (InspIRCd* Instance) : Command(Instance,NULL,"CLEARCACHE","o",0) { }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for commands.
*/
- CommandCommands (InspIRCd* Instance) : Command(Instance,"COMMANDS",0,0) { }
+ CommandCommands (InspIRCd* Instance) : Command(Instance,NULL,"COMMANDS",0,0) { }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for connect.
*/
- CommandConnect (InspIRCd* Instance) : Command(Instance,"CONNECT","o",1,false,0) { syntax = "<servername> [<remote-server>]"; }
+ CommandConnect (InspIRCd* Instance) : Command(Instance,NULL,"CONNECT","o",1,false,0) { syntax = "<servername> [<remote-server>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for die.
*/
- CommandDie (InspIRCd* Instance) : Command(Instance,"DIE","o",1,false,0) { syntax = "<password>"; }
+ CommandDie (InspIRCd* Instance) : Command(Instance,
NULL,"DIE","o",1,false,0) { syntax = "<password>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for eline.
*/
- CommandEline (InspIRCd* Instance) : Command(Instance,"ELINE","o",1,3,false,0) { syntax = "<ident@host> [<duration> :<reason>]"; }
+ CommandEline (InspIRCd* Instance) : Command(Instance,NULL,"ELINE","o",1,3,false,0) { syntax = "<ident@host> [<duration> :<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for gline.
*/
- CommandGline (InspIRCd* Instance) : Command(Instance,"GLINE","o",1,3,false,0) { syntax = "<ident@host> [<duration> :<reason>]"; }
+ CommandGline (InspIRCd* Instance) : Command(Instance,NULL,"GLINE","o",1,3,false,0) { syntax = "<ident@host> [<duration> :<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for info.
*/
- CommandInfo (InspIRCd* Instance) : Command(Instance,"INFO",0,0) { syntax = "[<servermask>]"; }
+ CommandInfo (InspIRCd* Instance) : Command(Instance,NULL,"INFO",0,0) { syntax = "[<servermask>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for invite.
*/
- CommandInvite (InspIRCd* Instance) : Command(Instance,"INVITE", 0, 0, false, 4) { syntax = "[<nick> <channel>]"; }
+ CommandInvite (InspIRCd* Instance) : Command(Instance,NULL,"INVITE", 0, 0, false, 4) { syntax = "[<nick> <channel>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for ison.
*/
- CommandIson (InspIRCd* Instance) : Command(Instance,"ISON",0,0) { syntax = "<nick> {nick}"; }
+ CommandIson (InspIRCd* Instance) : Command(Instance,NULL,"ISON",0,0) { syntax = "<nick> {nick}"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for join.
*/
- CommandJoin (InspIRCd* Instance) : Command(Instance,"JOIN", 0, 1, false, 2) { syntax = "<channel>{,<channel>} {<key>{,<key>}}"; }
+ CommandJoin (InspIRCd* Instance) : Command(Instance,NULL,"JOIN", 0, 1, false, 2) { syntax = "<channel>{,<channel>} {<key>{,<key>}}"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for kick.
*/
- CommandKick (InspIRCd* Instance) : Command(Instance,"KICK",0,2) { syntax = "<channel> <nick>{,<nick>} [<reason>]"; }
+ CommandKick (InspIRCd* Instance) : Command(Instance,NULL,"KICK",0,2) { syntax = "<channel> <nick>{,<nick>} [<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for kill.
*/
- CommandKill (InspIRCd* Instance) : Command(Instance,"KILL","o",2,false,0) { syntax = "<nickname> <reason>"; }
+ CommandKill (InspIRCd* Instance) : Command(Instance,NULL,"KILL","o",2,false,0) { syntax = "<nickname> <reason>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for kline.
*/
- CommandKline (InspIRCd* Instance) : Command(Instance,"KLINE","o",1,3,false,0) { syntax = "<ident@host> [<duration> :<reason>]"; }
+ CommandKline (InspIRCd* Instance) : Command(Instance,NULL,"KLINE","o",1,3,false,0) { syntax = "<ident@host> [<duration> :<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for links.
*/
- CommandLinks (InspIRCd* Instance) : Command(Instance,"LINKS",0,0) { }
+ CommandLinks (InspIRCd* Instance) : Command(Instance,NULL,"LINKS",0,0) { }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for list.
*/
- CommandList (InspIRCd* Instance) : Command(Instance,"LIST", 0, 0, false, 5) { }
+ CommandList (InspIRCd* Instance) : Command(Instance,NULL,"LIST", 0, 0, false, 5) { }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for loadmodule.
*/
- CommandLoadmodule (InspIRCd* Instance) : Command(Instance,"LOADMODULE","o",1) { syntax = "<modulename>"; }
+ CommandLoadmodule (InspIRCd* Instance) : Command(Instance,NULL,"LOADMODULE","o",1) { syntax = "<modulename>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for lusers.
*/
- CommandLusers (InspIRCd* Instance) : Command(Instance,"LUSERS",0,0) { }
+ CommandLusers (InspIRCd* Instance) : Command(Instance,NULL,"LUSERS",0,0) { }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for map.
*/
- CommandMap (InspIRCd* Instance) : Command(Instance,"MAP",0,0,false,2) { }
+ CommandMap (InspIRCd* Instance) : Command(Instance,NULL,"MAP",0,0,false,2) { }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for mode.
*/
- CommandMode (InspIRCd* Instance) : Command(Instance,"MODE",0,1) { syntax = "<target> <modes> {<mode-parameters>}"; }
+ CommandMode (InspIRCd* Instance) : Command(Instance,NULL,"MODE",0,1) { syntax = "<target> <modes> {<mode-parameters>}"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for modules.
*/
- CommandModules (InspIRCd* Instance) : Command(Instance,"MODULES",0,0) { syntax = "[debug]"; }
+ CommandModules (InspIRCd* Instance) : Command(Instance,NULL,"MODULES",0,0) { syntax = "[debug]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for motd.
*/
- CommandMotd (InspIRCd* Instance) : Command(Instance,"MOTD",0,0) { syntax = "[<servername>]"; }
+ CommandMotd (InspIRCd* Instance) : Command(Instance,NULL,"MOTD",0,0) { syntax = "[<servername>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for names.
*/
- CommandNames (InspIRCd* Instance) : Command(Instance,"NAMES",0,0) { syntax = "{<channel>{,<channel>}}"; }
+ CommandNames (InspIRCd* Instance) : Command(Instance,NULL,"NAMES",0,0) { syntax = "{<channel>{,<channel>}}"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for nick.
*/
- CommandNick (InspIRCd* Instance) : Command(Instance,"NICK", 0, 1, true, 3), allowinvalid(false) { syntax = "<newnick>"; }
+ CommandNick (InspIRCd* Instance) : Command(Instance,NULL,"NICK", 0, 1, true, 3), allowinvalid(false) { syntax = "<newnick>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for notice.
*/
- CommandNotice (InspIRCd* Instance) : Command(Instance,"NOTICE",0,2) { syntax = "<target>{,<target>} <message>"; }
+ CommandNotice (InspIRCd* Instance) : Command(Instance,NULL,"NOTICE",0,2) { syntax = "<target>{,<target>} <message>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for oper.
*/
- CommandOper (InspIRCd* Instance) : Command(Instance,"OPER",0,2,false,2) { syntax = "<username> <password>"; }
+ CommandOper (InspIRCd* Instance) : Command(Instance,
NULL,"OPER",0,2,false,2) { syntax = "<username> <password>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for part.
*/
- CommandPart (InspIRCd* Instance) : Command(Instance,"PART", 0, 1, false, 5) { syntax = "<channel>{,<channel>} [<reason>]"; }
+ CommandPart (InspIRCd* Instance) : Command(Instance,NULL,"PART", 0, 1, false, 5) { syntax = "<channel>{,<channel>} [<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for pass.
*/
- CommandPass (InspIRCd* Instance) : Command(Instance,"PASS",0,1,true,0) { syntax = "<password>"; }
+ CommandPass (InspIRCd* Instance) : Command(Instance,
NULL,"PASS",0,1,true,0) { syntax = "<password>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for ping.
*/
- CommandPing (InspIRCd* Instance) : Command(Instance,"PING", 0, 1, false, 0) { syntax = "<servername> [:<servername>]"; }
+ CommandPing (InspIRCd* Instance) : Command(Instance,NULL,"PING", 0, 1, false, 0) { syntax = "<servername> [:<servername>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for pong.
*/
- CommandPong (InspIRCd* Instance) : Command(Instance,"PONG", 0, 1, false, 0) { syntax = "<ping-text>"; }
+ CommandPong (InspIRCd* Instance) : Command(Instance,
NULL,"PONG", 0, 1, false, 0) { syntax = "<ping-text>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for privmsg.
*/
- CommandPrivmsg (InspIRCd* Instance) : Command(Instance,"PRIVMSG",0,2) { syntax = "<target>{,<target>} <message>"; }
+ CommandPrivmsg (InspIRCd* Instance) : Command(Instance,NULL,"PRIVMSG",0,2) { syntax = "<target>{,<target>} <message>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for qline.
*/
- CommandQline (InspIRCd* Instance) : Command(Instance,"QLINE","o",1,3,false,0) { syntax = "<nick> [<duration> :<reason>]"; }
+ CommandQline (InspIRCd* Instance) : Command(Instance,NULL,"QLINE","o",1,3,false,0) { syntax = "<nick> [<duration> :<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for quit.
*/
- CommandQuit (InspIRCd* Instance) : Command(Instance,"QUIT",0,0,true) { syntax = "[<message>]"; }
+ CommandQuit (InspIRCd* Instance) : Command(Instance,NULL,"QUIT",0,0,true) { syntax = "[<message>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for rehash.
*/
- CommandRehash (InspIRCd* Instance) : Command(Instance,"REHASH","o",0,false,3) { syntax = "[<servermask>]"; }
+ CommandRehash (InspIRCd* Instance) : Command(Instance,NULL,"REHASH","o",0,false,3) { syntax = "[<servermask>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for reloadmodule.
*/
- CommandReloadmodule (InspIRCd* Instance) : Command(Instance,"RELOADMODULE","o",1) { syntax = "<modulename>"; }
+ CommandReloadmodule (InspIRCd* Instance) : Command(Instance,NULL,"RELOADMODULE","o",1) { syntax = "<modulename>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for restart.
*/
- CommandRestart (InspIRCd* Instance) : Command(Instance,"RESTART","o",1,false,0) { syntax = "<password>"; }
+ CommandRestart (InspIRCd* Instance) : Command(Instance,
NULL,"RESTART","o",1,false,0) { syntax = "<password>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for rules.
*/
- CommandRules (InspIRCd* Instance) : Command(Instance,"RULES",0,0) { syntax = "[<servername>]"; }
+ CommandRules (InspIRCd* Instance) : Command(Instance,NULL,"RULES",0,0) { syntax = "[<servername>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for server.
*/
- CommandServer (InspIRCd* Instance) : Command(Instance,"SERVER",0,0,true) { }
+ CommandServer (InspIRCd* Instance) : Command(Instance,NULL,"SERVER",0,0,true) { }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for squit.
*/
- CommandSquit (InspIRCd* Instance) : Command(Instance,"SQUIT","o",1) { syntax = "<servername> [<reason>]"; }
+ CommandSquit (InspIRCd* Instance) : Command(Instance,NULL,"SQUIT","o",1) { syntax = "<servername> [<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for stats.
*/
- CommandStats (InspIRCd* Instance) : Command(Instance,"STATS",0,1) { syntax = "<stats-symbol> [<servername>]"; }
+ CommandStats (InspIRCd* Instance) : Command(Instance,NULL,"STATS",0,1) { syntax = "<stats-symbol> [<servername>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for time.
*/
- CommandTime (InspIRCd* Instance) : Command(Instance,"TIME",0,0) { syntax = "[<servername>]"; }
+ CommandTime (InspIRCd* Instance) : Command(Instance,NULL,"TIME",0,0) { syntax = "[<servername>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for topic.
*/
- CommandTopic (InspIRCd* Instance) : Command(Instance,"TOPIC",0,1,false,2) { syntax = "<channel> [<topic>]"; }
+ CommandTopic (InspIRCd* Instance) : Command(Instance,NULL,"TOPIC",0,1,false,2) { syntax = "<channel> [<topic>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for trace.
*/
- CommandTrace (InspIRCd* Instance) : Command(Instance,"TRACE","o",0) { syntax = "[<object>]"; }
+ CommandTrace (InspIRCd* Instance) : Command(Instance,NULL,"TRACE","o",0) { syntax = "[<object>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for unloadmodule.
*/
- CommandUnloadmodule (InspIRCd* Instance) : Command(Instance,"UNLOADMODULE","o",1) { syntax = "<modulename>"; }
+ CommandUnloadmodule (InspIRCd* Instance) : Command(Instance,NULL,"UNLOADMODULE","o",1) { syntax = "<modulename>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for user.
*/
- CommandUser (InspIRCd* Instance) : Command(Instance,"USER",0,4,true,0) { syntax = "<username> <localhost> <remotehost> <GECOS>"; }
+ CommandUser (InspIRCd* Instance) : Command(Instance,NULL,"USER",0,4,true,0) { syntax = "<username> <localhost> <remotehost> <GECOS>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for userhost.
*/
- CommandUserhost (InspIRCd* Instance) : Command(Instance,"USERHOST",0,1) { syntax = "<nick>{,<nick>}"; }
+ CommandUserhost (InspIRCd* Instance) : Command(Instance,NULL,"USERHOST",0,1) { syntax = "<nick>{,<nick>}"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for version.
*/
- CommandVersion (InspIRCd* Instance) : Command(Instance,"VERSION",0,0) { syntax = "[<servername>]"; }
+ CommandVersion (InspIRCd* Instance) : Command(Instance,NULL,"VERSION",0,0) { syntax = "[<servername>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for wallops.
*/
- CommandWallops (InspIRCd* Instance) : Command(Instance,"WALLOPS","o",1,1) { syntax = "<any-text>"; }
+ CommandWallops (InspIRCd* Instance) : Command(Instance,
NULL,"WALLOPS","o",1,1) { syntax = "<any-text>"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for who.
*/
- CommandWho (InspIRCd* Instance) : Command(Instance,"WHO", 0, 1, false, 2) { syntax = "<server>|<nickname>|<channel>|<realname>|<host>|0 [ohurmMiaplf]"; }
+ CommandWho (InspIRCd* Instance) : Command(Instance,NULL,"WHO", 0, 1, false, 2) { syntax = "<server>|<nickname>|<channel>|<realname>|<host>|0 [ohurmMiaplf]"; }
void SendWhoLine(User* user, const std::string &initial, Channel* ch, User* u, std::vector<std::string> &whoresults);
/** Handle command.
* @param parameters The parameters to the comamnd
public:
/** Constructor for whois.
*/
- CommandWhois (InspIRCd* Instance) : Command(Instance,"WHOIS",0,1,false,2) { syntax = "<nick>{,<nick>}"; }
+ CommandWhois (InspIRCd* Instance) : Command(Instance,NULL,"WHOIS",0,1,false,2) { syntax = "<nick>{,<nick>}"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Constructor for zline.
*/
- CommandZline (InspIRCd* Instance) : Command(Instance,"ZLINE","o",1,3,false,0) { syntax = "<ipmask> [<duration> :<reason>]"; }
+ CommandZline (InspIRCd* Instance) : Command(Instance,NULL,"ZLINE","o",1,3,false,0) { syntax = "<ipmask> [<duration> :<reason>]"; }
/** Handle command.
* @param parameters The parameters to the comamnd
* @param pcnt The number of parameters passed to teh command
public:
/** Command name
*/
- std::string command;
+ std::string command;
+
+ /** Creator module, NULL for core commands */
+ Module* creator;
/** User flags needed to execute the command or 0
*/
long double use_count;
/** used by /stats m
- */
- long double total_bytes;
-
- /** used for resource tracking between modules
*/
- std::string source;
+ long double total_bytes;
/** True if the command is disabled to non-opers
*/
* be allowed before the user is 'registered' (has sent USER,
* NICK, optionally PASS, and been resolved).
*/
- Command(InspIRCd* Instance, const std::string &cmd, const char *flags, int minpara, bool before_reg = false, int penalty = 1) : ServerInstance(Instance), command(cmd), flags_needed(flags ? *flags : 0), min_params(minpara), max_params(0), disabled(false), works_before_reg(before_reg), Penalty(penalty)
+ Command(InspIRCd* Instance, Module* me, const std::string &cmd, const char *flags, int minpara, bool before_reg = false, int penalty = 1) :
+ ServerInstance(Instance), command(cmd), creator(me), flags_needed(flags ? *flags : 0),
+ min_params(minpara), max_params(0), disabled(false), works_before_reg(before_reg), Penalty(penalty)
{
use_count = 0;
total_bytes = 0;
- source = "<core>";
- syntax = "";
- translation.clear();
}
- Command(InspIRCd* Instance, const std::string &cmd, const char *flags, int minpara, int maxpara, bool before_reg = false, int penalty = 1) : ServerInstance(Instance), command(cmd), flags_needed(flags ? *flags : 0), min_params(minpara), max_params(maxpara), disabled(false), works_before_reg(before_reg), Penalty(penalty)
+ Command(InspIRCd* Instance, Module* me, const std::string &cmd, const char *flags, int minpara, int maxpara, bool before_reg = false, int penalty = 1) :
+ ServerInstance(Instance), command(cmd), creator(me), flags_needed(flags ? *flags : 0),
+ min_params(minpara), max_params(maxpara), disabled(false), works_before_reg(before_reg), Penalty(penalty)
{
use_count = 0;
total_bytes = 0;
- source = "<core>";
- syntax = "";
- translation.clear();
}
/** Handle the command from a user.
char prefixneeded;
public:
+ /** Module that created this mode. NULL for core modes */
+ Module* creator;
+
/**
* The constructor for ModeHandler initalizes the mode handler.
* The constructor of any class you derive from ModeHandler should
* In the core, the only modes to implement prefixes are +ovh (ops, voice, halfop) which define the prefix characters @, % and +
* and the rank values OP_VALUE, HALFOP_VALUE and VOICE_VALUE respectively. Any prefixes you define should have unique values proportional
* to these three defaults or proportional to another mode in a module you depend on. See src/cmode_o.cpp as an example.
+ * @param prefixrequired The prefix required to change this mode
+ * @param translate The translation type for the argument(s) of this mode
*/
- ModeHandler(InspIRCd* Instance, char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly,
- char mprefix = 0, char prefixrequired = '%', TranslateType translate = TR_TEXT);
+ ModeHandler(InspIRCd* Instance, Module* me, char modeletter, int parameters_on, int parameters_off,
+ bool listmode, ModeType type, bool operonly, char mprefix = 0,
+ char prefixrequired = '%', TranslateType translate = TR_TEXT);
/**
* The default destructor does nothing
*/
class CoreExport SimpleUserModeHandler : public ModeHandler
{
public:
- SimpleUserModeHandler(InspIRCd* Instance, char modeletter);
- virtual ~SimpleUserModeHandler();
+ SimpleUserModeHandler(InspIRCd* Instance, Module* Creator, char modeletter)
+ : ModeHandler(Instance, Creator, modeletter, 0, 0, false, MODETYPE_USER, false) {}
+ virtual ~SimpleUserModeHandler() {}
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool servermode = false);
};
class CoreExport SimpleChannelModeHandler : public ModeHandler
{
public:
- SimpleChannelModeHandler(InspIRCd* Instance, char modeletter);
- virtual ~SimpleChannelModeHandler();
+ SimpleChannelModeHandler(InspIRCd* Instance, Module* Creator, char modeletter)
+ : ModeHandler(Instance, Creator, modeletter, 0, 0, false, MODETYPE_CHANNEL, false) {}
+ virtual ~SimpleChannelModeHandler() {}
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool servermode = false);
};
bool tidy;
/** Config tag to check for max items per channel
*/
- std::string configtag;
+ std::string configtag;
/** Limits on a per-channel basis read from the tag
* specified in ListModeBase::configtag
*/
* @param autotidy Automatically tidy list entries on add
* @param ctag Configuration tag to get limits from
*/
- ListModeBase(InspIRCd* Instance, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist")
- : ModeHandler(Instance, modechar, 1, 1, true, MODETYPE_CHANNEL, false), listnumeric(lnum), endoflistnumeric(eolnum), endofliststring(eolstr), tidy(autotidy), configtag(ctag)
+ ListModeBase(InspIRCd* Instance, Module* Creator, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist")
+ : ModeHandler(Instance, Creator, modechar, 1, 1, true, MODETYPE_CHANNEL, false), listnumeric(lnum), endoflistnumeric(eolnum), endofliststring(eolstr), tidy(autotidy), configtag(ctag)
{
this->DoRehash();
infokey = "listbase_mode_" + std::string(1, mode) + "_list";
if (n != cmdlist.end())
{
- if ((pcnt >= n->second->min_params) && (n->second->source != "<core>"))
+ if ((pcnt >= n->second->min_params) && (n->second->creator != NULL))
{
if (IS_LOCAL(user) && n->second->flags_needed)
{
}
}
-void CommandParser::RemoveCommands(const char* source)
+void CommandParser::RemoveCommands(Module* source)
{
Commandtable::iterator i,safei;
for (i = cmdlist.begin(); i != cmdlist.end();)
delete reload;
}
-void CommandParser::RemoveCommand(Commandtable::iterator safei, const char* source)
+void CommandParser::RemoveCommand(Commandtable::iterator safei, Module* source)
{
Command* x = safei->second;
- if (x->source == std::string(source))
+ if (x->creator == source)
{
cmdlist.erase(safei);
}
{
for (Commandtable::iterator i = ServerInstance->Parser->cmdlist.begin(); i != ServerInstance->Parser->cmdlist.end(); i++)
{
+ Module* src = i->second->creator;
user->WriteNumeric(RPL_COMMANDS, "%s :%s %s %d %d",
user->nick.c_str(),
i->second->command.c_str(),
- i->second->source.c_str(),
+ src ? src->ModuleSourceFile.c_str() : "<core>",
i->second->min_params,
i->second->Penalty);
}
return new CommandWhowas(Instance);
}
-CommandWhowas::CommandWhowas(InspIRCd* Instance) : Command(Instance, "WHOWAS", 0, 1, false, 2)
+CommandWhowas::CommandWhowas(InspIRCd* Instance) : Command(Instance, NULL, "WHOWAS", 0, 1, false, 2)
{
syntax = "<nick>{,<nick>}";
timer = new WhoWasMaintainTimer(Instance, 3600);
/* +s (server notice masks) */
#include "modes/umode_s.h"
-ModeHandler::ModeHandler(InspIRCd* Instance, char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly, char mprefix, char prefixrequired, TranslateType translate)
- : ServerInstance(Instance), mode(modeletter), n_params_on(parameters_on), n_params_off(parameters_off), list(listmode), m_type(type), m_paramtype(translate), oper(operonly), prefix(mprefix), count(0), prefixneeded(prefixrequired)
+ModeHandler::ModeHandler(InspIRCd* Instance, Module* Creator, char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly, char mprefix, char prefixrequired, TranslateType translate)
+ : ServerInstance(Instance), mode(modeletter), n_params_on(parameters_on), n_params_off(parameters_off), list(listmode), m_type(type), m_paramtype(translate), oper(operonly), prefix(mprefix), count(0), prefixneeded(prefixrequired), creator(Creator)
{
}
return (theirs < ours);
}
-SimpleUserModeHandler::SimpleUserModeHandler(InspIRCd* Instance, char modeletter) : ModeHandler(Instance, modeletter, 0, 0, false, MODETYPE_USER, false)
-{
-}
-
-SimpleUserModeHandler::~SimpleUserModeHandler()
-{
-}
-
-SimpleChannelModeHandler::~SimpleChannelModeHandler()
-{
-}
-
-SimpleChannelModeHandler::SimpleChannelModeHandler(InspIRCd* Instance, char modeletter) : ModeHandler(Instance, modeletter, 0, 0, false, MODETYPE_CHANNEL, false)
-{
-}
-
ModeAction SimpleUserModeHandler::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool servermode)
{
if (adding)
#include "hashcomp.h"
#include "modes/cmode_b.h"
-ModeChannelBan::ModeChannelBan(InspIRCd* Instance) : ModeHandler(Instance, 'b', 1, 1, true, MODETYPE_CHANNEL, false)
+ModeChannelBan::ModeChannelBan(InspIRCd* Instance) : ModeHandler(Instance, NULL, 'b', 1, 1, true, MODETYPE_CHANNEL, false)
{
}
#include "modules.h"
#include "modes/cmode_h.h"
-ModeChannelHalfOp::ModeChannelHalfOp(InspIRCd* Instance) : ModeHandler(Instance, 'h', 1, 1, true, MODETYPE_CHANNEL, false, '%', '@', TR_NICK)
+ModeChannelHalfOp::ModeChannelHalfOp(InspIRCd* Instance) : ModeHandler(Instance, NULL, 'h', 1, 1, true, MODETYPE_CHANNEL, false, '%', '@', TR_NICK)
{
}
#include "users.h"
#include "modes/cmode_i.h"
-ModeChannelInviteOnly::ModeChannelInviteOnly(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'i')
+ModeChannelInviteOnly::ModeChannelInviteOnly(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'i')
{
}
#include "users.h"
#include "modes/cmode_k.h"
-ModeChannelKey::ModeChannelKey(InspIRCd* Instance) : ModeHandler(Instance, 'k', 1, 1, false, MODETYPE_CHANNEL, false)
+ModeChannelKey::ModeChannelKey(InspIRCd* Instance) : ModeHandler(Instance, NULL, 'k', 1, 1, false, MODETYPE_CHANNEL, false)
{
}
#include "users.h"
#include "modes/cmode_l.h"
-ModeChannelLimit::ModeChannelLimit(InspIRCd* Instance) : ModeHandler(Instance, 'l', 1, 0, false, MODETYPE_CHANNEL, false)
+ModeChannelLimit::ModeChannelLimit(InspIRCd* Instance) : ModeHandler(Instance, NULL, 'l', 1, 0, false, MODETYPE_CHANNEL, false)
{
}
#include "users.h"
#include "modes/cmode_m.h"
-ModeChannelModerated::ModeChannelModerated(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'm')
+ModeChannelModerated::ModeChannelModerated(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'm')
{
}
#include "users.h"
#include "modes/cmode_n.h"
-ModeChannelNoExternal::ModeChannelNoExternal(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'n')
+ModeChannelNoExternal::ModeChannelNoExternal(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'n')
{
}
#include "modules.h"
#include "modes/cmode_o.h"
-ModeChannelOp::ModeChannelOp(InspIRCd* Instance) : ModeHandler(Instance, 'o', 1, 1, true, MODETYPE_CHANNEL, false, '@', '@', TR_NICK)
+ModeChannelOp::ModeChannelOp(InspIRCd* Instance) : ModeHandler(Instance, NULL, 'o', 1, 1, true, MODETYPE_CHANNEL, false, '@', '@', TR_NICK)
{
}
#include "users.h"
#include "modes/cmode_p.h"
-ModeChannelPrivate::ModeChannelPrivate(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'p')
+ModeChannelPrivate::ModeChannelPrivate(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 'p')
{
}
#include "users.h"
#include "modes/cmode_s.h"
-ModeChannelSecret::ModeChannelSecret(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 's')
+ModeChannelSecret::ModeChannelSecret(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, NULL, 's')
{
}
#include "users.h"
#include "modes/cmode_t.h"
-ModeChannelTopicOps::ModeChannelTopicOps(InspIRCd* Instance) : ModeHandler(Instance, 't', 0, 0, false, MODETYPE_CHANNEL, false)
+ModeChannelTopicOps::ModeChannelTopicOps(InspIRCd* Instance) : ModeHandler(Instance, NULL, 't', 0, 0, false, MODETYPE_CHANNEL, false)
{
}
#include "modules.h"
#include "modes/cmode_v.h"
-ModeChannelVoice::ModeChannelVoice(InspIRCd* Instance) : ModeHandler(Instance, 'v', 1, 1, true, MODETYPE_CHANNEL, false, '+', '%', TR_NICK)
+ModeChannelVoice::ModeChannelVoice(InspIRCd* Instance) : ModeHandler(Instance, NULL, 'v', 1, 1, true, MODETYPE_CHANNEL, false, '+', '%', TR_NICK)
{
}
#include "users.h"
#include "modes/umode_i.h"
-ModeUserInvisible::ModeUserInvisible(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'i')
+ModeUserInvisible::ModeUserInvisible(InspIRCd* Instance) : SimpleUserModeHandler(Instance, NULL, 'i')
{
}
#include "users.h"
#include "modes/umode_o.h"
-ModeUserOperator::ModeUserOperator(InspIRCd* Instance) : ModeHandler(Instance, 'o', 0, 0, false, MODETYPE_USER, true)
+ModeUserOperator::ModeUserOperator(InspIRCd* Instance) : ModeHandler(Instance, NULL, 'o', 0, 0, false, MODETYPE_USER, true)
{
}
#include "users.h"
#include "modes/umode_s.h"
-ModeUserServerNoticeMask::ModeUserServerNoticeMask(InspIRCd* Instance) : ModeHandler(Instance, 's', 1, 0, false, MODETYPE_USER, true)
+ModeUserServerNoticeMask::ModeUserServerNoticeMask(InspIRCd* Instance) : ModeHandler(Instance, NULL, 's', 1, 0, false, MODETYPE_USER, true)
{
}
#include "users.h"
#include "modes/umode_w.h"
-ModeUserWallops::ModeUserWallops(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'w')
+ModeUserWallops::ModeUserWallops(InspIRCd* Instance) : SimpleUserModeHandler(Instance, NULL, 'w')
{
}
this->DetachAll(modfind->second.second);
- Instance->Parser->RemoveCommands(filename);
+ Instance->Parser->RemoveCommands(modfind->second.second);
delete modfind->second.second;
delete modfind->second.first;
class CommandStartTLS : public Command
{
- Module* Caller;
public:
- CommandStartTLS (InspIRCd* Instance, Module* mod) : Command(Instance,"STARTTLS", 0, 0, true), Caller(mod)
+ CommandStartTLS (InspIRCd* Instance, Module* mod) : Command(Instance, mod, "STARTTLS", 0, 0, true)
{
- this->source = "m_ssl_gnutls.so";
}
CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
if (!user->GetIOHook())
{
user->WriteNumeric(670, "%s :STARTTLS successful, go ahead with TLS handshake", user->nick.c_str());
- user->AddIOHook(Caller);
- Caller->OnRawSocketAccept(user->GetFd(), NULL, NULL);
+ user->AddIOHook(creator);
+ creator->OnRawSocketAccept(user->GetFd(), NULL, NULL);
}
else
user->WriteNumeric(691, "%s :STARTTLS failure", user->nick.c_str());
class AllowInvite : public SimpleChannelModeHandler
{
public:
- AllowInvite(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'A') { }
+ AllowInvite(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'A') { }
};
class ModuleAllowInvite : public Module
AllowInvite ni;
public:
- ModuleAllowInvite(InspIRCd* Me) : Module(Me), ni(Me)
+ ModuleAllowInvite(InspIRCd* Me) : Module(Me), ni(Me, this)
{
if (!ServerInstance->Modes->AddMode(&ni))
throw ModuleException("Could not add new modes!");
class CommandAlltime : public Command
{
public:
- CommandAlltime(InspIRCd *Instance) : Command(Instance, "ALLTIME", "o", 0)
+ CommandAlltime(InspIRCd *Instance, Module* Creator) : Command(Instance, Creator, "ALLTIME", "o", 0)
{
- this->source = "m_alltime.so";
syntax.clear();
translation.push_back(TR_END);
}
CommandAlltime mycommand;
public:
Modulealltime(InspIRCd *Me)
- : Module(Me), mycommand(Me)
+ : Module(Me), mycommand(Me, this)
{
ServerInstance->AddCommand(&mycommand);
}
class AuditoriumMode : public ModeHandler
{
public:
- AuditoriumMode(InspIRCd* Instance) : ModeHandler(Instance, 'u', 0, 0, false, MODETYPE_CHANNEL, false, 0, '@') { }
+ AuditoriumMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'u', 0, 0, false, MODETYPE_CHANNEL, false, 0, '@') { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
bool OperOverride;
public:
ModuleAuditorium(InspIRCd* Me)
- : Module(Me), aum(Me)
+ : Module(Me), aum(Me, this)
{
if (!ServerInstance->Modes->AddMode(&aum))
throw ModuleException("Could not add new modes!");
class BanException : public ListModeBase
{
public:
- BanException(InspIRCd* Instance) : ListModeBase(Instance, 'e', "End of Channel Exception List", 348, 349, true) { }
+ BanException(InspIRCd* Instance, Module* Creator) : ListModeBase(Instance, Creator, 'e', "End of Channel Exception List", 348, 349, true) { }
};
BanException be;
public:
- ModuleBanException(InspIRCd* Me) : Module(Me), be(Me)
+ ModuleBanException(InspIRCd* Me) : Module(Me), be(Me, this)
{
if (!ServerInstance->Modes->AddMode(&be))
throw ModuleException("Could not add new modes!");
class BanRedirect : public ModeWatcher
{
public:
- BanRedirect(InspIRCd* Instance)
- : ModeWatcher(Instance, 'b', MODETYPE_CHANNEL)
+ BanRedirect(InspIRCd* Instance) : ModeWatcher(Instance, 'b', MODETYPE_CHANNEL)
{
}
class BlockCaps : public SimpleChannelModeHandler
{
public:
- BlockCaps(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'B') { }
+ BlockCaps(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'B') { }
};
class ModuleBlockCAPS : public Module
char capsmap[256];
public:
- ModuleBlockCAPS(InspIRCd* Me) : Module(Me), bc(Me)
+ ModuleBlockCAPS(InspIRCd* Me) : Module(Me), bc(Me, this)
{
OnRehash(NULL);
if (!ServerInstance->Modes->AddMode(&bc))
class BlockColor : public SimpleChannelModeHandler
{
public:
- BlockColor(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'c') { }
+ BlockColor(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'c') { }
};
class ModuleBlockColour : public Module
BlockColor bc;
public:
- ModuleBlockColour(InspIRCd* Me) : Module(Me), bc(Me)
+ ModuleBlockColour(InspIRCd* Me) : Module(Me), bc(Me, this)
{
if (!ServerInstance->Modes->AddMode(&bc))
throw ModuleException("Could not add new modes!");
class BotMode : public SimpleUserModeHandler
{
public:
- BotMode(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'B') { }
+ BotMode(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Instance, Creator, 'B') { }
};
class ModuleBotMode : public Module
BotMode bm;
public:
ModuleBotMode(InspIRCd* Me)
- : Module(Me), bm(Me)
+ : Module(Me), bm(Me, this)
{
if (!ServerInstance->Modes->AddMode(&bm))
throw ModuleException("Could not add new modes!");
class User_g : public SimpleUserModeHandler
{
public:
- User_g(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'g') { }
+ User_g(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Instance, Creator, 'g') { }
};
class CommandAccept : public Command
{
-private:
- unsigned int& maxaccepts;
public:
- CommandAccept(InspIRCd* Instance, unsigned int& max) : Command(Instance, "ACCEPT", 0, 1), maxaccepts(max)
+ unsigned int maxaccepts;
+ CommandAccept(InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "ACCEPT", 0, 1)
{
- source = "m_callerid.so";
syntax = "{[+|-]<nicks>}|*}";
TRANSLATE2(TR_CUSTOM, TR_END);
}
User_g myumode;
// Configuration variables:
- unsigned int maxaccepts; // Maximum ACCEPT entries.
bool operoverride; // Operators can override callerid.
bool tracknick; // Allow ACCEPT entries to update with nick changes.
unsigned int notify_cooldown; // Seconds between notifications.
}
public:
- ModuleCallerID(InspIRCd* Me) : Module(Me), mycommand(Me, maxaccepts), myumode(Me)
+ ModuleCallerID(InspIRCd* Me) : Module(Me), mycommand(Me, this), myumode(Me, this)
{
OnRehash(NULL);
virtual void OnRehash(User* user)
{
ConfigReader Conf(ServerInstance);
- maxaccepts = Conf.ReadInteger("callerid", "maxaccepts", "16", 0, true);
+ mycommand.maxaccepts = Conf.ReadInteger("callerid", "maxaccepts", "16", 0, true);
operoverride = Conf.ReadFlag("callerid", "operoverride", "0", 0);
tracknick = Conf.ReadFlag("callerid", "tracknick", "0", 0);
notify_cooldown = Conf.ReadInteger("callerid", "cooldown", "60", 0, true);
*/
class CommandCAP : public Command
{
- Module* Creator;
public:
- CommandCAP (InspIRCd* Instance, Module* mod) : Command(Instance,"CAP", 0, 1, true), Creator(mod)
+ CommandCAP (InspIRCd* Instance, Module* mod) : Command(Instance, mod, "CAP", 0, 1, true)
{
- this->source = "m_cap.so";
}
CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
Data.type = subcommand;
Data.user = user;
- Data.creator = this->Creator;
+ Data.creator = this->creator;
if (parameters.size() < 2)
return CMD_FAILURE;
}
user->Extend("CAP_REGHOLD");
- Event event((char*) &Data, (Module*)this->Creator, "cap_req");
+ Event event((char*) &Data, this->creator, "cap_req");
event.Send(this->ServerInstance);
if (Data.ack.size() > 0)
Data.type = subcommand;
Data.user = user;
- Data.creator = this->Creator;
+ Data.creator = this->creator;
user->Extend("CAP_REGHOLD");
- Event event((char*) &Data, (Module*)this->Creator, subcommand == "LS" ? "cap_ls" : "cap_list");
+ Event event((char*) &Data, this->creator, subcommand == "LS" ? "cap_ls" : "cap_list");
event.Send(this->ServerInstance);
std::string Result;
Data.type = subcommand;
Data.user = user;
- Data.creator = this->Creator;
+ Data.creator = this->creator;
user->Extend("CAP_REGHOLD");
- Event event((char*) &Data, (Module*)this->Creator, "cap_clear");
+ Event event((char*) &Data, this->creator, "cap_clear");
event.Send(this->ServerInstance);
std::string Result = irc::stringjoiner(" ", Data.ack, 0, Data.ack.size() - 1).GetJoined();
class CommandCBan : public Command
{
public:
- CommandCBan(InspIRCd* Me) : Command(Me, "CBAN", "o", 1, 3)
+ CommandCBan(InspIRCd* Me, Module* Creator) : Command(Me, Creator, "CBAN", "o", 1, 3)
{
- this->source = "m_cban.so";
this->syntax = "<channel> [<duration> :<reason>]";
TRANSLATE4(TR_TEXT,TR_TEXT,TR_TEXT,TR_END);
}
CBanFactory f;
public:
- ModuleCBan(InspIRCd* Me) : Module(Me), mycommand(Me), f(Me)
+ ModuleCBan(InspIRCd* Me) : Module(Me), mycommand(Me, this), f(Me)
{
ServerInstance->XLines->RegisterFactory(&f);
class CensorUser : public SimpleUserModeHandler
{
public:
- CensorUser(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'G') { }
+ CensorUser(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Instance, Creator, 'G') { }
};
/** Handles channel mode +G
class CensorChannel : public SimpleChannelModeHandler
{
public:
- CensorChannel(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'G') { }
+ CensorChannel(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'G') { }
};
class ModuleCensor : public Module
public:
ModuleCensor(InspIRCd* Me)
- : Module(Me), cu(Me), cc(Me)
+ : Module(Me), cu(Me, this), cc(Me, this)
{
/* Read the configuration file on startup.
*/
bool notify;
public:
CGIHostlist Hosts;
- CommandWebirc(InspIRCd* Instance, bool bnotify) : Command(Instance, "WEBIRC", 0, 4, true), notify(bnotify)
+ CommandWebirc(InspIRCd* Instance, Module* Creator, bool bnotify)
+ : Command(Instance, Creator, "WEBIRC", 0, 4, true), notify(bnotify)
{
- this->source = "m_cgiirc.so";
this->syntax = "password client hostname ip";
}
CmdResult Handle(const std::vector<std::string> ¶meters, User *user)
CommandWebirc cmd;
bool NotifyOpers;
public:
- ModuleCgiIRC(InspIRCd* Me) : Module(Me), cmd(Me, NotifyOpers)
+ ModuleCgiIRC(InspIRCd* Me) : Module(Me), cmd(Me, this, NotifyOpers)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmd);
class ChanFilter : public ListModeBase
{
public:
- ChanFilter(InspIRCd* Instance) : ListModeBase(Instance, 'g', "End of channel spamfilter list", 941, 940, false, "chanfilter") { }
+ ChanFilter(InspIRCd* Instance, Module* Creator) : ListModeBase(Instance, 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)
+ : Module(Me), cf(Me, this)
{
if (!ServerInstance->Modes->AddMode(&cf))
throw ModuleException("Could not add new modes!");
class ChanFounder : public ModeHandler, public FounderProtectBase
{
public:
- ChanFounder(InspIRCd* Instance, char my_prefix, bool &depriv_self, bool &depriv_others)
- : ModeHandler(Instance, 'q', 1, 1, true, MODETYPE_CHANNEL, false, my_prefix, 0, TR_NICK),
+ ChanFounder(InspIRCd* Instance, Module* Creator, char my_prefix, bool &depriv_self, bool &depriv_others)
+ : ModeHandler(Instance, Creator, 'q', 1, 1, true, MODETYPE_CHANNEL, false, my_prefix, 0, TR_NICK),
FounderProtectBase(Instance, "cm_founder_", "founder", 386, 387, depriv_self, depriv_others) { }
unsigned int GetPrefixRank()
class ChanProtect : public ModeHandler, public FounderProtectBase
{
public:
- ChanProtect(InspIRCd* Instance, char my_prefix, bool &depriv_self, bool &depriv_others)
- : ModeHandler(Instance, 'a', 1, 1, true, MODETYPE_CHANNEL, false, my_prefix, 0, TR_NICK),
+ ChanProtect(InspIRCd* Instance, Module* Creator, char my_prefix, bool &depriv_self, bool &depriv_others)
+ : ModeHandler(Instance, Creator, 'a', 1, 1, true, MODETYPE_CHANNEL, false, my_prefix, 0, TR_NICK),
FounderProtectBase(Instance,"cm_protect_","protected user", 388, 389, depriv_self, depriv_others) { }
unsigned int GetPrefixRank()
/* Initialise module variables */
- cp = new ChanProtect(ServerInstance, APrefix, DeprivSelf, DeprivOthers);
- cf = new ChanFounder(ServerInstance, QPrefix, DeprivSelf, DeprivOthers);
+ cp = new ChanProtect(ServerInstance, this, APrefix, DeprivSelf, DeprivOthers);
+ cf = new ChanFounder(ServerInstance, this, QPrefix, DeprivSelf, DeprivOthers);
if (!ServerInstance->Modes->AddMode(cp) || !ServerInstance->Modes->AddMode(cf))
{
*/
class CommandCheck : public Command
{
- Module* Parent;
public:
std::set<std::string> meta_seen;
- CommandCheck (InspIRCd* Instance, Module* parent) : Command(Instance,"CHECK", "o", 1), Parent(parent)
+ CommandCheck (InspIRCd* Instance, Module* parent) : Command(Instance,parent,"CHECK", "o", 1)
{
- this->source = "m_check.so";
syntax = "<nickname>|<ip>|<hostmask>|<channel>";
}
ServerInstance->DumpText(user,checkstr + " onchans ", dump);
- FOREACH_MOD_I(ServerInstance,I_OnSyncUser,OnSyncUser(targuser,Parent,(void*)user));
+ FOREACH_MOD_I(ServerInstance,I_OnSyncUser,OnSyncUser(targuser,creator,(void*)user));
dumpExtra(user, checkstr, targuser);
}
else if (targchan)
user->WriteServ(checkstr + " member " + tmpbuf);
}
- FOREACH_MOD_I(ServerInstance,I_OnSyncChannel,OnSyncChannel(targchan,Parent,(void*)user));
+ FOREACH_MOD_I(ServerInstance,I_OnSyncChannel,OnSyncChannel(targchan,creator,(void*)user));
dumpExtra(user, checkstr, targchan);
}
else
private:
char* hostmap;
public:
- CommandChghost (InspIRCd* Instance, char* hmap) : Command(Instance,"CHGHOST","o",2), hostmap(hmap)
+ CommandChghost (InspIRCd* Instance, Module* Creator, char* hmap) : Command(Instance,Creator,"CHGHOST","o",2), hostmap(hmap)
{
- this->source = "m_chghost.so";
syntax = "<nick> <newhost>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
char hostmap[256];
public:
ModuleChgHost(InspIRCd* Me)
- : Module(Me), cmd(Me, hostmap)
+ : Module(Me), cmd(Me, this, hostmap)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmd);
class CommandChgident : public Command
{
public:
- CommandChgident (InspIRCd* Instance) : Command(Instance,"CHGIDENT", "o", 2)
+ CommandChgident (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"CHGIDENT", "o", 2)
{
- this->source = "m_chgident.so";
syntax = "<nick> <newident>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
CommandChgident cmd;
public:
- ModuleChgIdent(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleChgIdent(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandChgname : public Command
{
public:
- CommandChgname (InspIRCd* Instance) : Command(Instance,"CHGNAME", "o", 2, 2)
+ CommandChgname (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"CHGNAME", "o", 2, 2)
{
- this->source = "m_chgname.so";
syntax = "<nick> <newname>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
CommandChgname cmd;
public:
- ModuleChgName(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleChgName(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
unsigned int key3;
unsigned int key4;
bool ipalways;
- Module* Sender;
Module* HashProvider;
const char *xtab[4];
return host.substr(splitdot);
}
- CloakUser(InspIRCd* Instance, Module* source, Module* Hash) : ModeHandler(Instance, 'x', 0, 0, false, MODETYPE_USER, false), Sender(source), HashProvider(Hash)
+ CloakUser(InspIRCd* Instance, Module* source, Module* Hash)
+ : ModeHandler(Instance, source, 'x', 0, 0, false, MODETYPE_USER, false), HashProvider(Hash)
{
}
if (!dest->GetExt("cloaked_host", cloak))
{
/* Force creation of missing cloak */
- Sender->OnUserConnect(dest);
+ creator->OnUserConnect(dest);
}
if (dest->GetExt("cloaked_host", cloak))
{
octet[1] = octet[0] + "." + octet[1];
/* Reset the Hash module and send it our IV */
- HashResetRequest(Sender, HashProvider).Send();
- HashKeyRequest(Sender, HashProvider, iv).Send();
+ HashResetRequest(creator, HashProvider).Send();
+ HashKeyRequest(creator, HashProvider, iv).Send();
/* Send the Hash module a different hex table for each octet group's Hash sum */
for (int k = 0; k < 4; k++)
{
- HashHexRequest(Sender, HashProvider, xtab[(iv[k]+i[k]) % 4]).Send();
- ra[k] = std::string(HashSumRequest(Sender, HashProvider, octet[k]).Send()).substr(0,6);
+ HashHexRequest(creator, HashProvider, xtab[(iv[k]+i[k]) % 4]).Send();
+ ra[k] = std::string(HashSumRequest(creator, HashProvider, octet[k]).Send()).substr(0,6);
}
/* Stick them all together */
return std::string().append(ra[0]).append(".").append(ra[1]).append(".").append(ra[2]).append(".").append(ra[3]);
int rounds = 0;
/* Reset the Hash module and send it our IV */
- HashResetRequest(Sender, HashProvider).Send();
- HashKeyRequest(Sender, HashProvider, iv).Send();
+ HashResetRequest(creator, HashProvider).Send();
+ HashKeyRequest(creator, HashProvider, iv).Send();
for (const char* input = ip; *input; input++)
{
if (item.length() > 7)
{
/* Send the Hash module a different hex table for each octet group's Hash sum */
- HashHexRequest(Sender, HashProvider, xtab[(key1+rounds) % 4]).Send();
- hashies.push_back(std::string(HashSumRequest(Sender, HashProvider, item).Send()).substr(0,8));
+ HashHexRequest(creator, HashProvider, xtab[(key1+rounds) % 4]).Send();
+ hashies.push_back(std::string(HashSumRequest(creator, HashProvider, item).Send()).substr(0,8));
item.clear();
}
rounds++;
if (!item.empty())
{
/* Send the Hash module a different hex table for each octet group's Hash sum */
- HashHexRequest(Sender, HashProvider, xtab[(key1+rounds) % 4]).Send();
- hashies.push_back(std::string(HashSumRequest(Sender, HashProvider, item).Send()).substr(0,8));
+ HashHexRequest(creator, HashProvider, xtab[(key1+rounds) % 4]).Send();
+ hashies.push_back(std::string(HashSumRequest(creator, HashProvider, item).Send()).substr(0,8));
item.clear();
}
/* Stick them all together */
class CommandClones : public Command
{
public:
- CommandClones (InspIRCd* Instance) : Command(Instance,"CLONES", "o", 1)
+ CommandClones (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"CLONES", "o", 1)
{
- this->source = "m_clones.so";
syntax = "<limit>";
}
private:
CommandClones cmd;
public:
- ModuleClones(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleClones(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
{
public:
/* Command 'close', needs operator */
- CommandClose (InspIRCd* Instance) : Command(Instance,"CLOSE", "o", 0)
+ CommandClose (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"CLOSE", "o", 0)
{
- this->source = "m_close.so";
}
CmdResult Handle (const std::vector<std::string> ¶meters, User *user)
CommandClose cmd;
public:
ModuleClose(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class PrivacyMode : public ModeHandler
{
public:
- PrivacyMode(InspIRCd* Instance) : ModeHandler(Instance, 'c', 0, 0, false, MODETYPE_USER, false) { }
+ PrivacyMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'c', 0, 0, false, MODETYPE_USER, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
{
PrivacyMode pm;
public:
- ModulePrivacyMode(InspIRCd* Me) : Module(Me), pm(Me)
+ ModulePrivacyMode(InspIRCd* Me) : Module(Me), pm(Me, this)
{
if (!ServerInstance->Modes->AddMode(&pm))
throw ModuleException("Could not add new modes!");
class CommandTitle : public Command
{
public:
- CommandTitle (InspIRCd* Instance) : Command(Instance,"TITLE",0,2)
+ CommandTitle (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"TITLE",0,2)
{
- this->source = "m_customtitle.so";
syntax = "<user> <password>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
CommandTitle cmd;
public:
- ModuleCustomTitle(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleCustomTitle(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
Implementation eventlist[] = { I_OnDecodeMetaData, I_OnWhoisLine, I_OnSyncUser, I_OnUserQuit, I_OnCleanup };
class CommandCycle : public Command
{
public:
- CommandCycle (InspIRCd* Instance) : Command(Instance,"CYCLE", 0, 1, false, 3)
+ CommandCycle (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"CYCLE", 0, 1, false, 3)
{
- this->source = "m_cycle.so";
syntax = "<channel> :[reason]";
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
CommandCycle cmd;
public:
ModuleCycle(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandDccallow : public Command
{
public:
- CommandDccallow(InspIRCd* Me) : Command(Me, "DCCALLOW", 0, 0)
+ CommandDccallow(InspIRCd* Me, Module* parent) : Command(Me, parent, "DCCALLOW", 0, 0)
{
- this->source = "m_dccallow.so";
syntax = "{[+|-]<nick> <time>|HELP|LIST}";
/* XXX we need to fix this so it can work with translation stuff (i.e. move +- into a seperate param */
}
public:
ModuleDCCAllow(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
Conf = new ConfigReader(ServerInstance);
ServerInstance->AddCommand(&cmd);
class User_d : public ModeHandler
{
public:
- User_d(InspIRCd* Instance) : ModeHandler(Instance, 'd', 0, 0, false, MODETYPE_USER, false) { }
+ User_d(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'd', 0, 0, false, MODETYPE_USER, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
public:
ModuleDeaf(InspIRCd* Me)
- : Module(Me), m1(Me)
+ : Module(Me), m1(Me, this)
{
if (!ServerInstance->Modes->AddMode(&m1))
throw ModuleException("Could not add new modes!");
{
private:
CUList empty;
- Module* Creator;
public:
- DelayJoinMode(InspIRCd* Instance, Module* Parent) : ModeHandler(Instance, 'D', 0, 0, false, MODETYPE_CHANNEL, false, 0, '@'), Creator(Parent) {};
+ DelayJoinMode(InspIRCd* Instance, Module* Parent) : ModeHandler(Instance, Parent, 'D', 0, 0, false, MODETYPE_CHANNEL, false, 0, '@') {};
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool);
};
*/
CUList* names = channel->GetUsers();
for (CUListIter n = names->begin(); n != names->end(); ++n)
- Creator->OnText(n->first, channel, TYPE_CHANNEL, "", 0, empty);
+ creator->OnText(n->first, channel, TYPE_CHANNEL, "", 0, empty);
}
channel->SetMode('D', adding);
return MODEACTION_ALLOW;
{
private:
CUList empty;
- Module* Creator;
public:
- DelayMsgMode(InspIRCd* Instance, Module* Parent) : ModeHandler(Instance, 'd', 1, 0, false, MODETYPE_CHANNEL, false, 0, '@'), Creator(Parent) {};
+ DelayMsgMode(InspIRCd* Instance, Module* Parent) : ModeHandler(Instance, Parent, 'd', 1, 0, false, MODETYPE_CHANNEL, false, 0, '@') {};
ModePair ModeSet(User*, User*, Channel* channel, const std::string ¶meter)
{
class CommandDevoice : public Command
{
public:
- CommandDevoice (InspIRCd* Instance) : Command(Instance,"DEVOICE", 0, 1)
+ CommandDevoice (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"DEVOICE", 0, 1)
{
- this->source = "m_devoice.so";
syntax = "<channel>";
TRANSLATE2(TR_TEXT, TR_END);
}
{
CommandDevoice cmd;
public:
- ModuleDeVoice(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleDeVoice(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
{
FilterBase* Base;
public:
- CommandFilter(FilterBase* f, InspIRCd* Me, const std::string &ssource) : Command(Me, "FILTER", "o", 1, 5), Base(f)
+ CommandFilter(FilterBase* f, InspIRCd* Me, const std::string &ssource)
+ : Command(Me, reinterpret_cast<Module*>(f), "FILTER", "o", 1, 5), Base(f)
{
- this->source = ssource;
this->syntax = "<filter-definition> <action> <flags> [<gline-duration>] :<reason>";
}
CmdResult Handle(const std::vector<std::string>&, User*);
class CommandGloadmodule : public Command
{
public:
- CommandGloadmodule (InspIRCd* Instance) : Command(Instance,"GLOADMODULE", "o", 1)
+ CommandGloadmodule (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"GLOADMODULE", "o", 1)
{
- this->source = "m_globalload.so";
syntax = "<modulename> [servermask]";
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
class CommandGunloadmodule : public Command
{
public:
- CommandGunloadmodule (InspIRCd* Instance) : Command(Instance,"GUNLOADMODULE", "o", 1)
+ CommandGunloadmodule (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"GUNLOADMODULE", "o", 1)
{
- this->source = "m_globalload.so";
syntax = "<modulename> [servermask]";
}
class CommandGreloadmodule : public Command
{
public:
- CommandGreloadmodule (InspIRCd* Instance) : Command(Instance, "GRELOADMODULE", "o", 1)
+ CommandGreloadmodule (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "GRELOADMODULE", "o", 1)
{
- this->source = "m_globalload.so";
syntax = "<modulename> [servermask]";
}
public:
ModuleGlobalLoad(InspIRCd* Me)
- : Module(Me), cmd1(Me), cmd2(Me), cmd3(Me)
+ : Module(Me), cmd1(Me, this), cmd2(Me, this), cmd3(Me, this)
{
ServerInstance->AddCommand(&cmd1);
ServerInstance->AddCommand(&cmd2);
class CommandGlobops : public Command
{
public:
- CommandGlobops (InspIRCd* Instance) : Command(Instance,"GLOBOPS","o",1,1)
+ CommandGlobops (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"GLOBOPS","o",1,1)
{
- this->source = "m_globops.so";
syntax = "<any-text>";
TRANSLATE2(TR_TEXT, TR_END);
}
CommandGlobops cmd;
public:
ModuleGlobops(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
ServerInstance->SNO->EnableSnomask('g',"GLOBOPS");
class Helpop : public ModeHandler
{
public:
- Helpop(InspIRCd* Instance) : ModeHandler(Instance, 'h', 0, 0, false, MODETYPE_USER, true) { }
+ Helpop(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'h', 0, 0, false, MODETYPE_USER, true) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
class CommandHelpop : public Command
{
public:
- CommandHelpop (InspIRCd* Instance) : Command(Instance, "HELPOP", 0, 0)
+ CommandHelpop (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "HELPOP", 0, 0)
{
- this->source = "m_helpop.so";
syntax = "<any-text>";
}
public:
ModuleHelpop(InspIRCd* Me)
- : Module(Me), cmd(Me), ho(Me)
+ : Module(Me), cmd(Me, this), ho(Me, this)
{
ReadConfig();
if (!ServerInstance->Modes->AddMode(&ho))
class HideChans : public ModeHandler
{
public:
- HideChans(InspIRCd* Instance) : ModeHandler(Instance, 'I', 0, 0, false, MODETYPE_USER, false) { }
+ HideChans(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'I', 0, 0, false, MODETYPE_USER, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
bool AffectsOpers;
HideChans hm;
public:
- ModuleHideChans(InspIRCd* Me) : Module(Me), hm(Me)
+ ModuleHideChans(InspIRCd* Me) : Module(Me), hm(Me, this)
{
if (!ServerInstance->Modes->AddMode(&hm))
throw ModuleException("Could not add new modes!");
class HideOper : public ModeHandler
{
public:
- HideOper(InspIRCd* Instance) : ModeHandler(Instance, 'H', 0, 0, false, MODETYPE_USER, true) { }
+ HideOper(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'H', 0, 0, false, MODETYPE_USER, true) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
HideOper hm;
public:
ModuleHideOper(InspIRCd* Me)
- : Module(Me), hm(Me)
+ : Module(Me), hm(Me, this)
{
if (!ServerInstance->Modes->AddMode(&hm))
{
QuietOper* qo;
public:
- InvisibleMode(InspIRCd* Instance) : ModeHandler(Instance, 'Q', 0, 0, false, MODETYPE_USER, true)
+ InvisibleMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'Q', 0, 0, false, MODETYPE_USER, true)
{
qo = new QuietOper();
}
InvisibleDeOper ido;
public:
ModuleInvisible(InspIRCd* Me)
- : Module(Me), qm(Me), ido(Me)
+ : Module(Me), qm(Me, this), ido(Me)
{
conf = new ConfigReader(ServerInstance);
if (!ServerInstance->Modes->AddMode(&qm))
class InviteException : public ListModeBase
{
public:
- InviteException(InspIRCd* Instance) : ListModeBase(Instance, 'I', "End of Channel Invite Exception List", 346, 347, true) { }
+ InviteException(InspIRCd* Instance, Module* Creator) : ListModeBase(Instance, 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)
+ ModuleInviteException(InspIRCd* Me) : Module(Me), ie(Me, this)
{
if (!ServerInstance->Modes->AddMode(&ie))
throw ModuleException("Could not add new modes!");
class JoinFlood : public ModeHandler
{
public:
- JoinFlood(InspIRCd* Instance) : ModeHandler(Instance, 'j', 1, 0, false, MODETYPE_CHANNEL, false) { }
+ JoinFlood(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'j', 1, 0, false, MODETYPE_CHANNEL, false) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
ModuleJoinFlood(InspIRCd* Me)
- : Module(Me), jf(Me)
+ : Module(Me), jf(Me, this)
{
if (!ServerInstance->Modes->AddMode(&jf))
std::string reason;
int port;
- CommandJumpserver (InspIRCd* Instance) : Command(Instance, "JUMPSERVER", "o", 0, 4)
+ CommandJumpserver (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "JUMPSERVER", "o", 0, 4)
{
- this->source = "m_jumpserver.so";
syntax = "[<server> <port> <+/-an> <reason>]";
redirect_to.clear();
reason.clear();
CommandJumpserver js;
public:
ModuleJumpServer(InspIRCd* Me)
- : Module(Me), js(Me)
+ : Module(Me), js(Me, this)
{
ServerInstance->AddCommand(&js);
Implementation eventlist[] = { I_OnUserRegister };
class KickRejoin : public ModeHandler
{
public:
- KickRejoin(InspIRCd* Instance) : ModeHandler(Instance, 'J', 1, 0, false, MODETYPE_CHANNEL, false) { }
+ KickRejoin(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'J', 1, 0, false, MODETYPE_CHANNEL, false) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
ModuleKickNoRejoin(InspIRCd* Me)
- : Module(Me), kr(Me)
+ : Module(Me), kr(Me, this)
{
if (!ServerInstance->Modes->AddMode(&kr))
throw ModuleException("Could not add new modes!");
class CommandKnock : public Command
{
public:
- CommandKnock (InspIRCd* Instance) : Command(Instance,"KNOCK", 0, 2)
+ CommandKnock (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"KNOCK", 0, 2)
{
- this->source = "m_knock.so";
syntax = "<channel> <reason>";
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
class Knock : public SimpleChannelModeHandler
{
public:
- Knock(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'K') { }
+ Knock(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'K') { }
};
class ModuleKnock : public Module
CommandKnock cmd;
Knock kn;
public:
- ModuleKnock(InspIRCd* Me) : Module(Me), cmd(Me), kn(Me)
+ ModuleKnock(InspIRCd* Me) : Module(Me), cmd(Me, this), kn(Me, this)
{
if (!ServerInstance->Modes->AddMode(&kn))
throw ModuleException("Could not add new modes!");
class CommandLockserv : public Command
{
-private:
bool& locked;
-
public:
- CommandLockserv (InspIRCd* Instance, bool &lock)
- : Command(Instance, "LOCKSERV", "o", 0), locked(lock)
+ CommandLockserv (InspIRCd* Instance, Module* Creator, bool& lock)
+ : Command(Instance, Creator, "LOCKSERV", "o", 0), locked(lock)
{
- this->source = "m_lockserv.so";
syntax.clear();
}
bool& locked;
public:
- CommandUnlockserv (InspIRCd* Instance, bool &lock)
- : Command(Instance, "UNLOCKSERV", "o", 0), locked(lock)
+ CommandUnlockserv (InspIRCd* Instance, Module* Creator, bool &lock)
+ : Command(Instance, Creator, "UNLOCKSERV", "o", 0), locked(lock)
{
- this->source = "m_lockserv.so";
syntax.clear();
}
}
public:
- ModuleLockserv(InspIRCd* Me) : Module(Me), lockcommand(Me, locked), unlockcommand(Me, locked)
+ ModuleLockserv(InspIRCd* Me) : Module(Me), lockcommand(Me, this, locked), unlockcommand(Me, this, locked)
{
ResetLocked();
ServerInstance->AddCommand(&lockcommand);
class MsgFlood : public ModeHandler
{
public:
- MsgFlood(InspIRCd* Instance) : ModeHandler(Instance, 'f', 1, 0, false, MODETYPE_CHANNEL, false) { }
+ MsgFlood(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'f', 1, 0, false, MODETYPE_CHANNEL, false) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
ModuleMsgFlood(InspIRCd* Me)
- : Module(Me), mf(Me)
+ : Module(Me), mf(Me, this)
{
if (!ServerInstance->Modes->AddMode(&mf))
throw ModuleException("Could not add new modes!");
class NickFlood : public ModeHandler
{
public:
- NickFlood(InspIRCd* Instance) : ModeHandler(Instance, 'F', 1, 0, false, MODETYPE_CHANNEL, false) { }
+ NickFlood(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'F', 1, 0, false, MODETYPE_CHANNEL, false) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
ModuleNickFlood(InspIRCd* Me)
- : Module(Me), jf(Me)
+ : Module(Me), jf(Me, this)
{
if (!ServerInstance->Modes->AddMode(&jf))
throw ModuleException("Could not add new modes!");
{
public:
- CommandNicklock (InspIRCd* Instance) : Command(Instance,"NICKLOCK", "o", 2)
+ CommandNicklock (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"NICKLOCK", "o", 2)
{
- this->source = "m_nicklock.so";
syntax = "<oldnick> <newnick>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
class CommandNickunlock : public Command
{
public:
- CommandNickunlock (InspIRCd* Instance) : Command(Instance,"NICKUNLOCK", "o", 1)
+ CommandNickunlock (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"NICKUNLOCK", "o", 1)
{
- this->source = "m_nicklock.so";
syntax = "<locked-nick>";
TRANSLATE2(TR_NICK, TR_END);
}
class ModuleNickLock : public Module
{
- CommandNicklock cmd1;
- CommandNickunlock cmd2;
+ CommandNicklock cmd1;
+ CommandNickunlock cmd2;
public:
ModuleNickLock(InspIRCd* Me)
- : Module(Me), cmd1(Me), cmd2(Me)
+ : Module(Me), cmd1(Me, this), cmd2(Me, this)
{
ServerInstance->AddCommand(&cmd1);
ServerInstance->AddCommand(&cmd2);
class NoCTCP : public ModeHandler
{
public:
- NoCTCP(InspIRCd* Instance) : ModeHandler(Instance, 'C', 0, 0, false, MODETYPE_CHANNEL, false) { }
+ NoCTCP(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'C', 0, 0, false, MODETYPE_CHANNEL, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
public:
ModuleNoCTCP(InspIRCd* Me)
- : Module(Me), nc(Me)
+ : Module(Me), nc(Me, this)
{
if (!ServerInstance->Modes->AddMode(&nc))
throw ModuleException("Could not add new modes!");
class NoKicks : public SimpleChannelModeHandler
{
public:
- NoKicks(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'Q') { }
+ NoKicks(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'Q') { }
};
class ModuleNoKicks : public Module
public:
ModuleNoKicks(InspIRCd* Me)
- : Module(Me), nk(Me)
+ : Module(Me), nk(Me, this)
{
if (!ServerInstance->Modes->AddMode(&nk))
throw ModuleException("Could not add new modes!");
class NoNicks : public ModeHandler
{
public:
- NoNicks(InspIRCd* Instance) : ModeHandler(Instance, 'N', 0, 0, false, MODETYPE_CHANNEL, false) { }
+ NoNicks(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'N', 0, 0, false, MODETYPE_CHANNEL, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
{
NoNicks nn;
public:
- ModuleNoNickChange(InspIRCd* Me) : Module(Me), nn(Me)
+ ModuleNoNickChange(InspIRCd* Me) : Module(Me), nn(Me, this)
{
ServerInstance->Modes->AddMode(&nn);
Implementation eventlist[] = { I_OnUserPreNick, I_On005Numeric };
class NoNotice : public SimpleChannelModeHandler
{
public:
- NoNotice(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'T') { }
+ NoNotice(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'T') { }
};
class ModuleNoNotice : public Module
public:
ModuleNoNotice(InspIRCd* Me)
- : Module(Me), nt(Me)
+ : Module(Me), nt(Me, this)
{
if (!ServerInstance->Modes->AddMode(&nt))
throw ModuleException("Could not add new modes!");
{
public:
/* This is an oper-only mode */
- OperChans(InspIRCd* Instance) : ModeHandler(Instance, 'O', 0, 0, false, MODETYPE_CHANNEL, true) { }
+ OperChans(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'O', 0, 0, false, MODETYPE_CHANNEL, true) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
OperChans oc;
public:
ModuleOperChans(InspIRCd* Me)
- : Module(Me), oc(Me)
+ : Module(Me), oc(Me, this)
{
if (!ServerInstance->Modes->AddMode(&oc))
throw ModuleException("Could not add new modes!");
class CommandOpermotd : public Command
{
public:
- CommandOpermotd (InspIRCd* Instance) : Command(Instance,"OPERMOTD", "o", 0)
+ CommandOpermotd (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"OPERMOTD", "o", 0)
{
- this->source = "m_opermotd.so";
syntax = "[<servername>]";
}
}
ModuleOpermotd(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
opermotd = NULL;
ServerInstance->AddCommand(&cmd);
class OperPrefixMode : public ModeHandler
{
public:
- OperPrefixMode(InspIRCd* Instance, char pfx) : ModeHandler(Instance, 'y', 1, 1, true, MODETYPE_CHANNEL, false, pfx, pfx, TR_NICK) { }
+ OperPrefixMode(InspIRCd* Instance, Module* Creator, char pfx) : ModeHandler(Instance, Creator, 'y', 1, 1, true, MODETYPE_CHANNEL, false, pfx, pfx, TR_NICK) { }
unsigned int GetPrefixRank()
{
ConfigReader Conf(ServerInstance);
std::string pfx = Conf.ReadValue("operprefix", "prefix", "!", 0, false);
- opm = new OperPrefixMode(ServerInstance, pfx[0]);
+ opm = new OperPrefixMode(ServerInstance, this, pfx[0]);
if ((!ServerInstance->Modes->AddMode(opm)))
throw ModuleException("Could not add a new mode!");
*/
class CommandMkpasswd : public Command
{
- Module* Sender;
hashymodules &hashers;
std::deque<std::string> &names;
public:
- CommandMkpasswd (InspIRCd* Instance, Module* S, hashymodules &h, std::deque<std::string> &n)
- : Command(Instance,"MKPASSWD", 0, 2), Sender(S), hashers(h), names(n)
+ CommandMkpasswd (InspIRCd* Instance, Module* Creator, hashymodules &h, std::deque<std::string> &n)
+ : Command(Instance, Creator, "MKPASSWD", 0, 2), hashers(h), names(n)
{
- this->source = "m_password_hash.so";
syntax = "<hashtype> <any-text>";
}
if (x != hashers.end())
{
/* Yup, reset it first (Always ALWAYS do this) */
- HashResetRequest(Sender, x->second).Send();
+ HashResetRequest(creator, x->second).Send();
/* Now attempt to generate a hash */
- user->WriteServ("NOTICE %s :%s hashed password for %s is %s",user->nick.c_str(), algo, stuff, HashSumRequest(Sender, x->second, stuff).Send() );
+ user->WriteServ("NOTICE %s :%s hashed password for %s is %s",user->nick.c_str(), algo, stuff, HashSumRequest(creator, x->second, stuff).Send() );
}
else if (names.empty())
{
class PermChannel : public ModeHandler
{
public:
- PermChannel(InspIRCd* Instance) : ModeHandler(Instance, 'P', 0, 0, false, MODETYPE_CHANNEL, false) { }
+ PermChannel(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'P', 0, 0, false, MODETYPE_CHANNEL, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool sm)
{
PermChannel p;
public:
- ModulePermanentChannels(InspIRCd* Me) : Module(Me), p(Me)
+ ModulePermanentChannels(InspIRCd* Me) : Module(Me), p(Me, this)
{
if (!ServerInstance->Modes->AddMode(&p))
throw ModuleException("Could not add new modes!");
class CommandRandquote : public Command
{
public:
- CommandRandquote (InspIRCd* Instance) : Command(Instance,"RANDQUOTE", 0, 0)
+ CommandRandquote (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"RANDQUOTE", 0, 0)
{
- this->source = "m_randquote.so";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
ConfigReader *conf;
public:
ModuleRandQuote(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
conf = new ConfigReader(ServerInstance);
class Redirect : public ModeHandler
{
public:
- Redirect(InspIRCd* Instance) : ModeHandler(Instance, 'L', 1, 0, false, MODETYPE_CHANNEL, false) { }
+ Redirect(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'L', 1, 0, false, MODETYPE_CHANNEL, false) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
ModuleRedirect(InspIRCd* Me)
- : Module(Me), re(Me)
+ : Module(Me), re(Me, this)
{
if (!ServerInstance->Modes->AddMode(&re))
class CommandRemove : public Command, public RemoveBase
{
public:
- CommandRemove(InspIRCd* Instance, bool& snk) : Command(Instance, "REMOVE", 0, 2, 2, false, 0), RemoveBase(Instance, snk)
+ CommandRemove(InspIRCd* Instance, Module* Creator, bool& snk)
+ : Command(Instance, Creator, "REMOVE", 0, 2, 2, false, 0), RemoveBase(Instance, snk)
{
- this->source = "m_remove.so";
syntax = "<nick> <channel> [<reason>]";
TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END);
}
class CommandFpart : public Command, public RemoveBase
{
public:
- CommandFpart(InspIRCd* Instance, bool& snk) : Command(Instance, "FPART", 0, 2), RemoveBase(Instance, snk)
+ CommandFpart(InspIRCd* Instance, Module* Creator, bool& snk)
+ : Command(Instance, Creator, "FPART", 0, 2), RemoveBase(Instance, snk)
{
- this->source = "m_remove.so";
syntax = "<channel> <nick> [<reason>]";
}
public:
ModuleRemove(InspIRCd* Me)
- : Module(Me), cmd1(Me, supportnokicks), cmd2(Me, supportnokicks)
+ : Module(Me), cmd1(Me, this, supportnokicks), cmd2(Me, this, supportnokicks)
{
ServerInstance->AddCommand(&cmd1);
ServerInstance->AddCommand(&cmd2);
std::string rxengine;
public:
- CommandRLine (InspIRCd* Instance) : Command(Instance,"RLINE", "o", 1, 3)
+ CommandRLine (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"RLINE", "o", 1, 3)
{
- this->source = "m_rline.so";
this->syntax = "<regex> [<rline-duration>] :<reason>";
}
std::string RegexEngine;
public:
- ModuleRLine(InspIRCd* Me) : Module(Me), r(Me), f(Me)
+ ModuleRLine(InspIRCd* Me) : Module(Me), r(Me, this), f(Me)
{
mymodule = this;
OnRehash(NULL);
class CommandSajoin : public Command
{
public:
- CommandSajoin (InspIRCd* Instance) : Command(Instance,"SAJOIN", "o", 2, false, 0)
+ CommandSajoin (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SAJOIN", "o", 2, false, 0)
{
- this->source = "m_sajoin.so";
syntax = "<nick> <channel>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
CommandSajoin cmd;
public:
ModuleSajoin(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSakick : public Command
{
public:
- CommandSakick (InspIRCd* Instance) : Command(Instance,"SAKICK", "o", 2, 3, false, 0)
+ CommandSakick (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SAKICK", "o", 2, 3, false, 0)
{
- this->source = "m_sakick.so";
syntax = "<channel> <nick> [reason]";
TRANSLATE4(TR_TEXT, TR_NICK, TR_TEXT, TR_END);
}
CommandSakick cmd;
public:
ModuleSakick(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSamode : public Command
{
public:
- CommandSamode (InspIRCd* Instance) : Command(Instance,"SAMODE", "o", 2, false, 0)
+ CommandSamode (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SAMODE", "o", 2, false, 0)
{
- this->source = "m_samode.so";
syntax = "<target> <modes> {<mode-parameters>}";
}
CommandSamode cmd;
public:
ModuleSaMode(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSanick : public Command
{
public:
- CommandSanick (InspIRCd* Instance) : Command(Instance,"SANICK", "o", 2, false, 0)
+ CommandSanick (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SANICK", "o", 2, false, 0)
{
- this->source = "m_sanick.so";
syntax = "<nick> <new-nick>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
CommandSanick cmd;
public:
ModuleSanick(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSapart : public Command
{
public:
- CommandSapart (InspIRCd* Instance) : Command(Instance,"SAPART", "o", 2, 3, false, 0)
+ CommandSapart (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SAPART", "o", 2, 3, false, 0)
{
- this->source = "m_sapart.so";
syntax = "<nick> <channel> [reason]";
TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END);
}
CommandSapart cmd;
public:
ModuleSapart(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSaquit : public Command
{
public:
- CommandSaquit (InspIRCd* Instance) : Command(Instance, "SAQUIT", "o", 2, 2, false, 0)
+ CommandSaquit (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "SAQUIT", "o", 2, 2, false, 0)
{
- this->source = "m_saquit.so";
syntax = "<nick> <reason>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
CommandSaquit cmd;
public:
ModuleSaquit(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
{
private:
InspIRCd *ServerInstance;
- Module *Creator;
std::string agent;
User *user;
SaslState state;
public:
SaslAuthenticator(User *user_, std::string method, InspIRCd *instance, Module *ctor)
- : ServerInstance(instance), Creator(ctor), user(user_), state(SASL_INIT), state_announced(false)
+ : ServerInstance(instance), user(user_), state(SASL_INIT), state_announced(false)
{
this->user->Extend("sasl_authenticator", this);
class CommandAuthenticate : public Command
{
- Module* Creator;
public:
- CommandAuthenticate (InspIRCd* Instance, Module* creator) : Command(Instance,"AUTHENTICATE", 0, 1, true), Creator(creator)
+ CommandAuthenticate (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "AUTHENTICATE", 0, 1, true)
{
- this->source = "m_sasl.so";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
SaslAuthenticator *sasl;
if (!(user->GetExt("sasl_authenticator", sasl)))
- sasl = new SaslAuthenticator(user, parameters[0], ServerInstance, Creator);
+ sasl = new SaslAuthenticator(user, parameters[0], ServerInstance, creator);
else if (sasl->SendClientMessage(parameters) == false) // IAL abort extension --nenolod
delete sasl;
}
class CommandSASL : public Command
{
- Module* Creator;
public:
- CommandSASL(InspIRCd* Instance, Module* creator) : Command(Instance, "SASL", 0, 2), Creator(creator)
+ CommandSASL(InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "SASL", 0, 2)
{
- this->source = "m_sasl.so";
this->disabled = true; // should not be called by users
}
class CommandSATopic : public Command
{
public:
- CommandSATopic (InspIRCd* Instance)
- : Command(Instance,"SATOPIC", "o", 2, 2, false, 0)
+ CommandSATopic (InspIRCd* Instance, Module* Creator)
+ : Command(Instance,Creator,"SATOPIC", "o", 2, 2, false, 0)
{
- this->source = "m_satopic.so";
syntax = "<target> <topic>";
}
CommandSATopic cmd;
public:
ModuleSATopic(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
{
public:
- Channel_r(InspIRCd* Instance) : ModeHandler(Instance, 'r', 0, 0, false, MODETYPE_CHANNEL, false) { }
+ Channel_r(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'r', 0, 0, false, MODETYPE_CHANNEL, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
{
public:
- User_r(InspIRCd* Instance) : ModeHandler(Instance, 'r', 0, 0, false, MODETYPE_USER, false) { }
+ User_r(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'r', 0, 0, false, MODETYPE_USER, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool servermode)
{
class AChannel_R : public SimpleChannelModeHandler
{
public:
- AChannel_R(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'R') { }
+ AChannel_R(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'R') { }
};
/** User mode +R - unidentified users cannot message
class AUser_R : public SimpleUserModeHandler
{
public:
- AUser_R(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'R') { }
+ AUser_R(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Instance, Creator, 'R') { }
};
/** Channel mode +M - unidentified users cannot message channel
class AChannel_M : public SimpleChannelModeHandler
{
public:
- AChannel_M(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'M') { }
+ AChannel_M(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'M') { }
};
class ModuleServicesAccount : public Module
User_r m5;
public:
ModuleServicesAccount(InspIRCd* Me) : Module(Me),
- m1(Me), m2(Me), m3(Me), m4(Me), m5(Me)
+ m1(Me, this), m2(Me, this), m3(Me, this), m4(Me, this), m5(Me, this)
{
if (!ServerInstance->Modes->AddMode(&m1) || !ServerInstance->Modes->AddMode(&m2) ||
class ServProtectMode : public ModeHandler
{
public:
- ServProtectMode(InspIRCd* Instance) : ModeHandler(Instance, 'k', 0, 0, false, MODETYPE_USER, true) { }
+ ServProtectMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'k', 0, 0, false, MODETYPE_USER, true) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
ServProtectMode bm;
public:
ModuleServProtectMode(InspIRCd* Me)
- : Module(Me), bm(Me)
+ : Module(Me), bm(Me, this)
{
if (!ServerInstance->Modes->AddMode(&bm))
throw ModuleException("Could not add new modes!");
private:
char* hostmap;
public:
- CommandSethost (InspIRCd* Instance, char* hmap) : Command(Instance,"SETHOST","o",1), hostmap(hmap)
+ CommandSethost (InspIRCd* Instance, Module* Creator, char* hmap) : Command(Instance,Creator,"SETHOST","o",1), hostmap(hmap)
{
- this->source = "m_sethost.so";
syntax = "<new-hostname>";
TRANSLATE2(TR_TEXT, TR_END);
}
char hostmap[256];
public:
ModuleSetHost(InspIRCd* Me)
- : Module(Me), cmd(Me, hostmap)
+ : Module(Me), cmd(Me, this, hostmap)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmd);
class CommandSetident : public Command
{
public:
- CommandSetident (InspIRCd* Instance) : Command(Instance,"SETIDENT", "o", 1)
+ CommandSetident (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SETIDENT", "o", 1)
{
- this->source = "m_setident.so";
syntax = "<new-ident>";
TRANSLATE2(TR_TEXT, TR_END);
}
CommandSetident cmd;
public:
- ModuleSetIdent(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleSetIdent(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSetidle : public Command
{
public:
- CommandSetidle (InspIRCd* Instance) : Command(Instance,"SETIDLE", "o", 1)
+ CommandSetidle (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SETIDLE", "o", 1)
{
- this->source = "m_setidle.so";
syntax = "<duration>";
TRANSLATE2(TR_TEXT, TR_END);
}
CommandSetidle cmd;
public:
ModuleSetIdle(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSetname : public Command
{
public:
- CommandSetname (InspIRCd* Instance) : Command(Instance,"SETNAME", 0, 1, 1)
+ CommandSetname (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SETNAME", 0, 1, 1)
{
- this->source = "m_setname.so";
syntax = "<new-gecos>";
TRANSLATE2(TR_TEXT, TR_END);
}
CommandSetname cmd;
public:
ModuleSetName(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class SeeWhois : public ModeHandler
{
public:
- SeeWhois(InspIRCd* Instance, bool IsOpersOnly) : ModeHandler(Instance, 'W', 0, 0, false, MODETYPE_USER, IsOpersOnly) { }
+ SeeWhois(InspIRCd* Instance, Module* Creator, bool IsOpersOnly) : ModeHandler(Instance, Creator, 'W', 0, 0, false, MODETYPE_USER, IsOpersOnly) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
class WhoisNoticeCmd : public Command
{
public:
- WhoisNoticeCmd(InspIRCd* Instance) : Command(Instance,"WHOISNOTICE", 0, 1)
+ WhoisNoticeCmd(InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"WHOISNOTICE", 0, 1)
{
- this->source = "m_showwhois.cpp";
}
void HandleFast(User* dest, User* src)
public:
- ModuleShowwhois(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleShowwhois(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ConfigReader conf(ServerInstance);
bool OpersOnly = conf.ReadFlag("showwhois", "opersonly", "yes", 0);
ShowWhoisFromOpers = conf.ReadFlag("showwhois", "showfromopers", "yes", 0);
- sw = new SeeWhois(ServerInstance, OpersOnly);
+ sw = new SeeWhois(ServerInstance, this, OpersOnly);
if (!ServerInstance->Modes->AddMode(sw))
throw ModuleException("Could not add new modes!");
ServerInstance->AddCommand(&cmd);
class CommandShun : public Command
{
public:
- CommandShun(InspIRCd* Me) : Command(Me, "SHUN", "o", 1, 3)
+ CommandShun(InspIRCd* Me, Module* Creator) : Command(Me, Creator, "SHUN", "o", 1, 3)
{
- this->source = "m_shun.so";
this->syntax = "<nick!user@hostmask> [<shun-duration>] :<reason>";
}
bool affectopers;
public:
- ModuleShun(InspIRCd* Me) : Module(Me), cmd(Me), f(Me)
+ ModuleShun(InspIRCd* Me) : Module(Me), cmd(Me, this), f(Me)
{
ServerInstance->XLines->RegisterFactory(&f);
ServerInstance->AddCommand(&cmd);
class CommandSVSSilence : public Command
{
public:
- CommandSVSSilence(InspIRCd* Instance) : Command(Instance,"SVSSILENCE", 0, 2)
+ CommandSVSSilence(InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SVSSILENCE", 0, 2)
{
- this->source = "m_silence.so";
syntax = "<target> {[+|-]<mask> <p|c|i|n|t|a|x>}";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END); /* we watch for a nick. not a UID. */
}
{
unsigned int& maxsilence;
public:
- CommandSilence (InspIRCd* Instance, unsigned int &max) : Command(Instance,"SILENCE", 0, 0), maxsilence(max)
+ CommandSilence (InspIRCd* Instance, Module* Creator, unsigned int &max) : Command(Instance, Creator, "SILENCE", 0, 0), maxsilence(max)
{
- this->source = "m_silence.so";
syntax = "{[+|-]<mask> <p|c|i|n|t|a|x>}";
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
public:
ModuleSilence(InspIRCd* Me)
- : Module(Me), maxsilence(32), cmdsilence(Me, maxsilence), cmdsvssilence(Me)
+ : Module(Me), maxsilence(32), cmdsilence(Me, this, maxsilence), cmdsvssilence(Me, this)
{
OnRehash(NULL);
ServerInstance->AddCommand(&cmdsilence);
}
else
{
- Module* srcmodule = ServerInstance->Modules->Find(thiscmd->source);
+ Module* srcmodule = thiscmd->creator;
if (srcmodule && !(srcmodule->GetVersion().Flags & VF_COMMON)) {
ServerInstance->Logs->Log("m_spanningtree",ERROR,"Routed command %s from non-VF_COMMON module %s",
- command.c_str(), thiscmd->source.c_str());
+ command.c_str(), srcmodule->ModuleSourceFile.c_str());
return;
}
}
/* $ModDep: 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 */
-CommandRConnect::CommandRConnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : Command(Instance, "RCONNECT", "o", 2), Creator(Callback), Utils(Util)
+CommandRConnect::CommandRConnect (InspIRCd* Instance, Module* Creator, SpanningTreeUtilities* Util)
+ : Command(Instance, Creator, "RCONNECT", "o", 2), Utils(Util)
{
- this->source = "m_spanningtree.so";
syntax = "<remote-server-mask> <target-server-mask>";
}
para.push_back(parameters[1]);
std::string cmd("CONNECT");
std::string original_command = cmd + " " + parameters[1];
- Creator->OnPreCommand(cmd, para, user, true, original_command);
+ creator->OnPreCommand(cmd, para, user, true, original_command);
}
return CMD_SUCCESS;
}
*/
class CommandRConnect : public Command
{
- Module* Creator; /* Creator */
SpanningTreeUtilities* Utils; /* Utility class */
public:
CommandRConnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util);
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h m_spanningtree/rsquit.h */
-CommandRSQuit::CommandRSQuit (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : Command(Instance, "RSQUIT", "o", 1), Creator(Callback), Utils(Util)
+CommandRSQuit::CommandRSQuit (InspIRCd* Instance, Module* Creator, SpanningTreeUtilities* Util)
+ : Command(Instance, Creator, "RSQUIT", "o", 1), Utils(Util)
{
- this->source = "m_spanningtree.so";
syntax = "<target-server-mask> [reason]";
}
*/
class CommandRSQuit : public Command
{
- Module* Creator; /* Creator */
SpanningTreeUtilities* Utils; /* Utility class */
public:
CommandRSQuit (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util);
class CommandSSLInfo : public Command
{
public:
- CommandSSLInfo (InspIRCd* Instance) : Command(Instance,"SSLINFO", 0, 1)
+ CommandSSLInfo(InspIRCd* Instance, Module* Creator) : Command(Instance, Creator, "SSLINFO", 0, 1)
{
- this->source = "m_sslinfo.so";
this->syntax = "<nick>";
}
CommandSSLInfo cmd;
public:
ModuleSSLInfo(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
class SSLMode : public ModeHandler
{
public:
- SSLMode(InspIRCd* Instance) : ModeHandler(Instance, 'z', 0, 0, false, MODETYPE_CHANNEL, false) { }
+ SSLMode(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'z', 0, 0, false, MODETYPE_CHANNEL, false) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
{
public:
ModuleSSLModes(InspIRCd* Me)
- : Module(Me), sslm(Me)
+ : Module(Me), sslm(Me, this)
{
if (!ServerInstance->Modes->AddMode(&sslm))
throw ModuleException("Could not add new modes!");
class ChannelStripColor : public SimpleChannelModeHandler
{
public:
- ChannelStripColor(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'S') { }
+ ChannelStripColor(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'S') { }
};
/** Handles user mode +S
class UserStripColor : public SimpleUserModeHandler
{
public:
- UserStripColor(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'S') { }
+ UserStripColor(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Instance, Creator, 'S') { }
};
UserStripColor usc;
public:
- ModuleStripColor(InspIRCd* Me) : Module(Me), csc(Me), usc(Me)
+ ModuleStripColor(InspIRCd* Me) : Module(Me), csc(Me, this), usc(Me, this)
{
if (!ServerInstance->Modes->AddMode(&usc) || !ServerInstance->Modes->AddMode(&csc))
throw ModuleException("Could not add new modes!");
class CommandSvshold : public Command
{
public:
- CommandSvshold(InspIRCd* Me) : Command(Me, "SVSHOLD", "o", 1)
+ CommandSvshold(InspIRCd* Me, Module* Creator) : Command(Me, Creator, "SVSHOLD", "o", 1)
{
- this->source = "m_svshold.so";
this->syntax = "<nickname> [<duration> :<reason>]";
TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END);
}
public:
- ModuleSVSHold(InspIRCd* Me) : Module(Me), cmd(Me), s(Me)
+ ModuleSVSHold(InspIRCd* Me) : Module(Me), cmd(Me, this), s(Me)
{
ServerInstance->XLines->RegisterFactory(&s);
ServerInstance->AddCommand(&cmd);
{
public:
- CommandSwhois (InspIRCd* Instance) : Command(Instance,"SWHOIS","o",2, 2)
+ CommandSwhois (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SWHOIS","o",2, 2)
{
- this->source = "m_swhois.so";
syntax = "<nick> :<swhois>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
ConfigReader* Conf;
public:
- ModuleSWhois(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleSWhois(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
Conf = new ConfigReader(ServerInstance);
*/
class CommandTaxonomy : public Command
{
- Module* Creator;
public:
/* Command 'taxonomy', takes no parameters and needs no special modes */
- CommandTaxonomy (InspIRCd* Instance, Module* maker) : Command(Instance,"TAXONOMY", "o", 1), Creator(maker)
+ CommandTaxonomy (InspIRCd* Instance, Module* maker) : Command(Instance,maker,"TAXONOMY", "o", 1)
{
- this->source = "m_taxonomy.so";
syntax = "<nickname>";
}
std::deque<std::string> list;
dest->GetExtList(list);
user->WriteNumeric(304, "" + std::string(user->nick) + ":TAXONOMY ITEMS " + std::string(dest->nick) + " " +ConvToStr(list.size()));
- FOREACH_MOD(I_OnSyncUser, OnSyncUser(dest, Creator, user));
+ FOREACH_MOD(I_OnSyncUser, OnSyncUser(dest, creator, user));
user->WriteNumeric(304, "" + std::string(user->nick) + ":TAXONOMY END");
}
return CMD_LOCALONLY;
class CommandTban : public Command
{
public:
- CommandTban (InspIRCd* Instance) : Command(Instance,"TBAN", 0, 3)
+ CommandTban (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"TBAN", 0, 3)
{
- this->source = "m_timedbans.so";
syntax = "<channel> <duration> <banmask>";
TRANSLATE4(TR_TEXT, TR_TEXT, TR_TEXT, TR_END);
}
CommandTban cmd;
public:
ModuleTimedBans(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
TimedBanList.clear();
class CommandTline : public Command
{
public:
- CommandTline (InspIRCd* Instance) : Command(Instance,"TLINE", "o", 1)
+ CommandTline (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"TLINE", "o", 1)
{
- this->source = "m_tline.so";
this->syntax = "<mask>";
}
CommandTline cmd;
public:
ModuleTLine(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandUninvite : public Command
{
public:
- CommandUninvite (InspIRCd* Instance) : Command(Instance,"UNINVITE", 0, 2)
+ CommandUninvite (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"UNINVITE", 0, 2)
{
- this->source = "m_uninvite.so";
syntax = "<nick> <channel>";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
public:
- ModuleUninvite(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleUninvite(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandUserip : public Command
{
public:
- CommandUserip (InspIRCd* Instance) : Command(Instance,"USERIP", "o", 1)
+ CommandUserip (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"USERIP", "o", 1)
{
- this->source = "m_userip.so";
syntax = "<nick>{,<nick>}";
}
CommandUserip cmd;
public:
ModuleUserIP(InspIRCd* Me)
- : Module(Me), cmd(Me)
+ : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
Implementation eventlist[] = { I_On005Numeric };
class CommandVhost : public Command
{
public:
- CommandVhost (InspIRCd* Instance) : Command(Instance,"VHOST", 0, 2)
+ CommandVhost (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"VHOST", 0, 2)
{
- this->source = "m_vhost.so";
syntax = "<username> <password>";
}
CommandVhost cmd;
public:
- ModuleVHost(InspIRCd* Me) : Module(Me), cmd(Me)
+ ModuleVHost(InspIRCd* Me) : Module(Me), cmd(Me, this)
{
ServerInstance->AddCommand(&cmd);
}
class CommandSVSWatch : public Command
{
public:
- CommandSVSWatch (InspIRCd* Instance) : Command(Instance,"SVSWATCH", 0, 2)
+ CommandSVSWatch (InspIRCd* Instance, Module* Creator) : Command(Instance, Creator,"SVSWATCH", 0, 2)
{
- this->source = "m_watch.so";
syntax = "<target> [C|L|S]|[+|-<nick>]";
TRANSLATE3(TR_NICK, TR_TEXT, TR_END); /* we watch for a nick. not a UID. */
}
return CMD_LOCALONLY;
}
- CommandWatch (InspIRCd* Instance, unsigned int &maxwatch) : Command(Instance,"WATCH",0,0), MAX_WATCH(maxwatch)
+ CommandWatch (InspIRCd* Instance, Module* parent, unsigned int &maxwatch) : Command(Instance,parent,"WATCH",0,0), MAX_WATCH(maxwatch)
{
- this->source = "m_watch.so";
syntax = "[C|L|S]|[+|-<nick>]";
TRANSLATE2(TR_TEXT, TR_END); /* we watch for a nick. not a UID. */
}
public:
Modulewatch(InspIRCd* Me)
- : Module(Me), maxwatch(32), cmdw(Me, maxwatch), sw(Me)
+ : Module(Me), maxwatch(32), cmdw(Me, this, maxwatch), sw(Me,this)
{
OnRehash(NULL);
whos_watching_me = new watchentries();
projects / user / henk / code / inspircd.git / commitdiff