* command simply did not exist at all or the wrong number of parameters were given, or the user
* was not privilaged enough to execute the command.
*/
- CmdResult CallHandler(const std::string &commandname,const char** parameters, int pcnt, User *user);
+ CmdResult CallHandler(const std::string &commandname,const char* const* parameters, int pcnt, User *user);
/** Get the handler function for a command.
* @param commandname The command required. Always use uppercase for this parameter.
* @return This function will return 1 when there are no more parameters to process. When this occurs, its
* caller should return without doing anything, otherwise it should continue into its main section of code.
*/
- int LoopCall(User* user, Command* CommandObj, const char** parameters, int pcnt, unsigned int splithere, unsigned int extra);
+ int LoopCall(User* user, Command* CommandObj, const char* const* parameters, int pcnt, unsigned int splithere, unsigned int extra);
/** LoopCall is used to call a command classes handler repeatedly based on the contents of a comma seperated list.
* There are two overriden versions of this method, one of which takes two potential lists and the other takes one.
* @return This function will return 1 when there are no more parameters to process. When this occurs, its
* caller should return without doing anything, otherwise it should continue into its main section of code.
*/
- int LoopCall(User* user, Command* CommandObj, const char** parameters, int pcnt, unsigned int splithere);
+ int LoopCall(User* user, Command* CommandObj, const char* const* parameters, int pcnt, unsigned int splithere);
/** Take a raw input buffer from a recvq, and process it on behalf of a user.
* @param buffer The buffer line to process
cmd_reload (InspIRCd* Instance) : Command(Instance,"RELOAD","o",1) { syntax = "<core-command>"; }
/** Handle RELOAD
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
/** A lookup table of values for multiplier characters used by
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
/** Handle internal command
* @param id Used to indicate if invalid nick changes are allowed.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
bool whomatch(User* user, const char* matchtext);
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
/** Handle an internal request from another command, the core, or a module
* @param Command ID
* @param Zero or more parameters, whos form is specified by the command ID.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const char** parameters, int pcnt, User *user);
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user);
};
#endif
* If the command succeeds but should remain local to this server,
* return CMD_LOCALONLY.
*/
- virtual CmdResult Handle(const char** parameters, int pcnt, User* user) = 0;
+ virtual CmdResult Handle(const char* const* parameters, int pcnt, User* user) = 0;
/** Handle an internal request from another command, the core, or a module
* @param Command ID
* If the command succeeds but should remain local to this server,
* return CMD_LOCALONLY.
*/
- virtual CmdResult HandleServer(const char** /* parameters */, int /* pcnt */, const std::string& /* servername */)
+ virtual CmdResult HandleServer(const char* const* /* parameters */, int /* pcnt */, const std::string& /* servername */)
{
return CMD_INVALID;
}
/** irc::stringjoiner joins string lists into a string, using
* the given seperator string.
* This class can join a vector of std::string, a deque of
- * std::string, or a const char** array, using overloaded
+ * std::string, or a const char* const* array, using overloaded
* constructors.
*/
class CoreExport stringjoiner
* @param begin The starting element in the sequence to be joined
* @param end The ending element in the sequence to be joined
*/
- stringjoiner(const std::string &seperator, const char** sequence, int begin, int end);
+ stringjoiner(const std::string &seperator, const char* const* sequence, int begin, int end);
/** Get the joined sequence
* @return A reference to the joined string
* @param pcnt The number of items you have given in the first parameter
* @param user The user to send error messages to
*/
- void SendMode(const char **parameters, int pcnt, User *user);
+ void SendMode(const char* const* parameters, int pcnt, User *user);
/** Match two strings using pattern matching.
* This operates identically to the global function match(),
* @param user The user to execute the command as
* @return True if the command handler was called successfully
*/
- CmdResult CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, User* user);
+ CmdResult CallCommandHandler(const std::string &commandname, const char* const* parameters, int pcnt, User* user);
/** Return true if the command is a module-implemented command and the given parameters are valid for it
* @param parameters The mode parameters
* and *user->server == NULL.
* @param servermode True if a server is setting the mode.
*/
- void Process(const char** parameters, int pcnt, User *user, bool servermode);
+ void Process(const char* const* parameters, int pcnt, User *user, bool servermode);
/** Find the mode handler for a given mode and type.
* @param modeletter mode letter to search for
* @param original_line The entire original line as passed to the parser from the user
* @return 1 to block the command, 0 to allow
*/
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line);
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line);
/** Called after any command has been executed.
* This event occurs for all registered commands, wether they are registered in the core,
* @param result The return code given by the command handler, one of CMD_SUCCESS or CMD_FAILURE
* @param original_line The entire original line as passed to the parser from the user
*/
- virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, User *user, CmdResult result, const std::string &original_line);
+ virtual void OnPostCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, CmdResult result, const std::string &original_line);
/** Called to check if a user who is connecting can now be allowed to register
* If any modules return false for this function, the user is held in the waiting
* The second version is much simpler and just has the one stream to read, and is used in NAMES, WHOIS, PRIVMSG etc.
* Both will only parse until they reach ServerInstance->Config->MaxTargets number of targets, to stop abuse via spam.
*/
-int CommandParser::LoopCall(User* user, Command* CommandObj, const char** parameters, int pcnt, unsigned int splithere, unsigned int extra)
+int CommandParser::LoopCall(User* user, Command* CommandObj, const char* const* parameters, int pcnt, unsigned int splithere, unsigned int extra)
{
/* First check if we have more than one item in the list, if we don't we return zero here and the handler
* which called us just carries on as it was.
return 1;
}
-int CommandParser::LoopCall(User* user, Command* CommandObj, const char** parameters, int pcnt, unsigned int splithere)
+int CommandParser::LoopCall(User* user, Command* CommandObj, const char* const* parameters, int pcnt, unsigned int splithere)
{
/* First check if we have more than one item in the list, if we don't we return zero here and the handler
* which called us just carries on as it was.
// calls a handler function for a command
-CmdResult CommandParser::CallHandler(const std::string &commandname,const char** parameters, int pcnt, User *user)
+CmdResult CommandParser::CallHandler(const std::string &commandname,const char* const* parameters, int pcnt, User *user)
{
Commandable::iterator n = cmdlist.find(commandname);
return false;
}
-CmdResult cmd_reload::Handle(const char** parameters, int /* pcnt */, User *user)
+CmdResult cmd_reload::Handle(const char* const* parameters, int /* pcnt */, User *user)
{
user->WriteServ("NOTICE %s :*** Reloading command '%s'",user->nick, parameters[0]);
if (ServerInstance->Parser->ReloadCommand(parameters[0], user))
/** Handle /ADMIN
*/
-CmdResult CommandAdmin::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandAdmin::Handle (const char* const* parameters, int pcnt, User *user)
{
user->WriteServ("256 %s :Administrative info for %s",user->nick,ServerInstance->Config->ServerName);
if (*ServerInstance->Config->AdminName)
/** Handle /AWAY
*/
-CmdResult CommandAway::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandAway::Handle (const char* const* parameters, int pcnt, User *user)
{
if ((pcnt) && (*parameters[0]))
{
/** Handle /CLEARCACHE
*/
-CmdResult CommandClearcache::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandClearcache::Handle (const char* const* parameters, int pcnt, User *user)
{
int n = ServerInstance->Res->ClearCache();
user->WriteServ("NOTICE %s :*** Cleared DNS cache of %d items.", user->nick, n);
return new CommandCommands(Instance);
}
-CmdResult CommandCommands::Handle (const char**, int, User *user)
+CmdResult CommandCommands::Handle (const char* const*, int, User *user)
{
for (Commandable::iterator i = ServerInstance->Parser->cmdlist.begin(); i != ServerInstance->Parser->cmdlist.end(); i++)
{
/** Handle /CONNECT
*/
-CmdResult CommandConnect::Handle (const char**, int, User *user)
+CmdResult CommandConnect::Handle (const char* const*, int, User *user)
{
user->WriteServ( "NOTICE %s :Look into loading a linking module (like m_spanningtree) if you want this to do anything useful.", user->nick);
return CMD_SUCCESS;
/** Handle /DIE
*/
-CmdResult CommandDie::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandDie::Handle (const char* const* parameters, int pcnt, User *user)
{
if (!ServerInstance->PassCompare(user, ServerInstance->Config->diepass, parameters[0], ServerInstance->Config->powerhash))
{
/** Handle /ELINE
*/
-CmdResult CommandEline::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandEline::Handle (const char* const* parameters, int pcnt, User *user)
{
std::string target = parameters[0];
/** Handle /GLINE
*/
-CmdResult CommandGline::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandGline::Handle (const char* const* parameters, int pcnt, User *user)
{
std::string target = parameters[0];
/** Handle /INFO
*/
-CmdResult CommandInfo::Handle (const char**, int, User *user)
+CmdResult CommandInfo::Handle (const char* const*, int, User *user)
{
user->WriteServ( "371 %s : -/\\- \2InspIRCd\2 -\\/-", user->nick);
user->WriteServ( "371 %s : November 2002 - Present", user->nick);
/** Handle /INVITE
*/
-CmdResult CommandInvite::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandInvite::Handle (const char* const* parameters, int pcnt, User *user)
{
int MOD_RESULT = 0;
/** Handle /ISON
*/
-CmdResult CommandIson::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandIson::Handle (const char* const* parameters, int pcnt, User *user)
{
std::map<User*,User*> ison_already;
User *u;
/** Handle /JOIN
*/
-CmdResult CommandJoin::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandJoin::Handle (const char* const* parameters, int pcnt, User *user)
{
if (pcnt > 1)
{
/** Handle /KICK
*/
-CmdResult CommandKick::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandKick::Handle (const char* const* parameters, int pcnt, User *user)
{
char reason[MAXKICK];
Channel* c = ServerInstance->FindChan(parameters[0]);
/** Handle /KILL
*/
-CmdResult CommandKill::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandKill::Handle (const char* const* parameters, int pcnt, User *user)
{
/* Allow comma seperated lists of users for /KILL (thanks w00t) */
if (ServerInstance->Parser->LoopCall(user, this, parameters, pcnt, 0))
/** Handle /KLINE
*/
-CmdResult CommandKline::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandKline::Handle (const char* const* parameters, int pcnt, User *user)
{
std::string target = parameters[0];
/** Handle /LINKS
*/
-CmdResult CommandLinks::Handle (const char**, int, User *user)
+CmdResult CommandLinks::Handle (const char* const*, int, User *user)
{
user->WriteServ("364 %s %s %s :0 %s",user->nick,ServerInstance->Config->ServerName,ServerInstance->Config->ServerName,ServerInstance->Config->ServerDesc);
user->WriteServ("365 %s * :End of /LINKS list.",user->nick);
return new CommandList(Instance);
}
-CmdResult CommandList::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandList::Handle (const char* const* parameters, int pcnt, User *user)
{
int minusers = 0, maxusers = 0;
/** Handle /LOADMODULE
*/
-CmdResult CommandLoadmodule::Handle (const char** parameters, int, User *user)
+CmdResult CommandLoadmodule::Handle (const char* const* parameters, int, User *user)
{
if (ServerInstance->Modules->Load(parameters[0]))
{
/** Handle /LUSERS
*/
-CmdResult CommandLusers::Handle (const char**, int, User *user)
+CmdResult CommandLusers::Handle (const char* const*, int, User *user)
{
// this lusers command shows one server at all times because
// a protocol module must override it to show those stats.
/** Handle /MAP
*/
-CmdResult CommandMap::Handle (const char**, int, User *user)
+CmdResult CommandMap::Handle (const char* const*, int, User *user)
{
// as with /LUSERS this does nothing without a linking
// module to override its behaviour and display something
/** Handle /MODE
*/
-CmdResult CommandMode::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandMode::Handle (const char* const* parameters, int pcnt, User *user)
{
ServerInstance->Modes->Process(parameters, pcnt, user, false);
return CMD_SUCCESS;
/** Handle /MODULES
*/
-CmdResult CommandModules::Handle (const char**, int, User *user)
+CmdResult CommandModules::Handle (const char* const*, int, User *user)
{
std::vector<std::string> module_names = ServerInstance->Modules->GetAllModuleNames(0);
/** Handle /MOTD
*/
-CmdResult CommandMotd::Handle (const char**, int, User *user)
+CmdResult CommandMotd::Handle (const char* const*, int, User *user)
{
user->ShowMOTD();
return CMD_SUCCESS;
/** Handle /NAMES
*/
-CmdResult CommandNames::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandNames::Handle (const char* const* parameters, int pcnt, User *user)
{
Channel* c;
* for the client introduction code in here, youre in the wrong place.
* You need to look in the spanningtree module for this!
*/
-CmdResult CommandNick::Handle (const char** parameters, int, User *user)
+CmdResult CommandNick::Handle (const char* const* parameters, int, User *user)
{
char oldnick[NICKMAX];
return new CommandNotice(Instance);
}
-CmdResult CommandNotice::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandNotice::Handle (const char* const* parameters, int pcnt, User *user)
{
User *dest;
Channel *chan;
FOREACH_RESULT(I_OnUserPreNotice,OnUserPreNotice(user,(void*)parameters[0],TYPE_SERVER,temp,0,exempt_list));
if (MOD_RESULT)
return CMD_FAILURE;
- parameters[1] = temp.c_str();
- // notice to server mask
+ const char* text = temp.c_str();
const char* servermask = parameters[0] + 1;
- FOREACH_MOD(I_OnText,OnText(user,(void*)parameters[0],TYPE_SERVER,parameters[1],0,exempt_list));
+
+ FOREACH_MOD(I_OnText,OnText(user,(void*)parameters[0],TYPE_SERVER,text,0,exempt_list));
if (match(ServerInstance->Config->ServerName,servermask))
{
- user->SendAll("NOTICE", "%s", parameters[1]);
+ user->SendAll("NOTICE", "%s", text);
}
- FOREACH_MOD(I_OnUserNotice,OnUserNotice(user,(void*)parameters[0],TYPE_SERVER,parameters[1],0,exempt_list));
+ FOREACH_MOD(I_OnUserNotice,OnUserNotice(user,(void*)parameters[0],TYPE_SERVER,text,0,exempt_list));
return CMD_SUCCESS;
}
char status = 0;
- if ((*parameters[0] == '@') || (*parameters[0] == '%') || (*parameters[0] == '+'))
+ const char* target = parameters[0];
+ if ((*target == '@') || (*target == '%') || (*target == '+'))
{
- status = *parameters[0];
- parameters[0]++;
+ status = *target;
+ target++;
}
- if (*parameters[0] == '#')
+ if (*target == '#')
{
- chan = ServerInstance->FindChan(parameters[0]);
+ chan = ServerInstance->FindChan(target);
exempt_list[user] = user->nick;
if (MOD_RESULT) {
return CMD_FAILURE;
}
- parameters[1] = temp.c_str();
+ const char* text = temp.c_str();
if (temp.empty())
{
return CMD_FAILURE;
}
- FOREACH_MOD(I_OnText,OnText(user,chan,TYPE_CHANNEL,parameters[1],status,exempt_list));
+ FOREACH_MOD(I_OnText,OnText(user,chan,TYPE_CHANNEL,text,status,exempt_list));
if (status)
{
if (ServerInstance->Config->UndernetMsgPrefix)
{
- chan->WriteAllExcept(user, false, status, exempt_list, "NOTICE %c%s :%c %s", status, chan->name, status, parameters[1]);
+ chan->WriteAllExcept(user, false, status, exempt_list, "NOTICE %c%s :%c %s", status, chan->name, status, text);
}
else
{
- chan->WriteAllExcept(user, false, status, exempt_list, "NOTICE %c%s :%s", status, chan->name, parameters[1]);
+ chan->WriteAllExcept(user, false, status, exempt_list, "NOTICE %c%s :%s", status, chan->name, text);
}
}
else
{
- chan->WriteAllExcept(user, false, status, exempt_list, "NOTICE %s :%s", chan->name, parameters[1]);
+ chan->WriteAllExcept(user, false, status, exempt_list, "NOTICE %s :%s", chan->name, text);
}
- FOREACH_MOD(I_OnUserNotice,OnUserNotice(user,chan,TYPE_CHANNEL,parameters[1],status,exempt_list));
+ FOREACH_MOD(I_OnUserNotice,OnUserNotice(user,chan,TYPE_CHANNEL,text,status,exempt_list));
}
else
{
/* no such nick/channel */
- user->WriteServ("401 %s %s :No such nick/channel",user->nick, parameters[0]);
+ user->WriteServ("401 %s %s :No such nick/channel",user->nick, target);
return CMD_FAILURE;
}
return CMD_SUCCESS;
if (MOD_RESULT) {
return CMD_FAILURE;
}
- parameters[1] = (char*)temp.c_str();
+ const char* text = temp.c_str();
- FOREACH_MOD(I_OnText,OnText(user,dest,TYPE_USER,parameters[1],0,exempt_list));
+ FOREACH_MOD(I_OnText,OnText(user,dest,TYPE_USER,text,0,exempt_list));
if (IS_LOCAL(dest))
{
// direct write, same server
- user->WriteTo(dest, "NOTICE %s :%s", dest->nick, parameters[1]);
+ user->WriteTo(dest, "NOTICE %s :%s", dest->nick, text);
}
- FOREACH_MOD(I_OnUserNotice,OnUserNotice(user,dest,TYPE_USER,parameters[1],0,exempt_list));
+ FOREACH_MOD(I_OnUserNotice,OnUserNotice(user,dest,TYPE_USER,text,0,exempt_list));
}
else
{
return new CommandOper(Instance);
}
-CmdResult CommandOper::Handle (const char** parameters, int, User *user)
+CmdResult CommandOper::Handle (const char* const* parameters, int, User *user)
{
char LoginName[MAXBUF];
char Password[MAXBUF];
return new CommandPart(Instance);
}
-CmdResult CommandPart::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandPart::Handle (const char* const* parameters, int pcnt, User *user)
{
std::string reason;
return new CommandPass(Instance);
}
-CmdResult CommandPass::Handle (const char** parameters, int, User *user)
+CmdResult CommandPass::Handle (const char* const* parameters, int, User *user)
{
// Check to make sure they havnt registered -- Fix by FCS
if (user->registered == REG_ALL)
return new CommandPing(Instance);
}
-CmdResult CommandPing::Handle (const char** parameters, int, User *user)
+CmdResult CommandPing::Handle (const char* const* parameters, int, User *user)
{
user->WriteServ("PONG %s :%s",ServerInstance->Config->ServerName,parameters[0]);
return CMD_SUCCESS;
return new CommandPong(Instance);
}
-CmdResult CommandPong::Handle (const char**, int, User *user)
+CmdResult CommandPong::Handle (const char* const*, int, User *user)
{
// set the user as alive so they survive to next ping
user->lastping = 1;
return new CommandPrivmsg(Instance);
}
-CmdResult CommandPrivmsg::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandPrivmsg::Handle (const char* const* parameters, int pcnt, User *user)
{
User *dest;
Channel *chan;
FOREACH_RESULT(I_OnUserPreMessage,OnUserPreMessage(user,(void*)parameters[0],TYPE_SERVER,temp,0,except_list));
if (MOD_RESULT)
return CMD_FAILURE;
- parameters[1] = temp.c_str();
- // notice to server mask
+ const char* text = temp.c_str();
const char* servermask = parameters[0] + 1;
- FOREACH_MOD(I_OnText,OnText(user,(void*)parameters[0],TYPE_SERVER,parameters[1],0,except_list));
+ FOREACH_MOD(I_OnText,OnText(user,(void*)parameters[0],TYPE_SERVER,text,0,except_list));
if (match(ServerInstance->Config->ServerName,servermask))
{
- user->SendAll("PRIVMSG", "%s", parameters[1]);
+ user->SendAll("PRIVMSG", "%s", text);
}
- FOREACH_MOD(I_OnUserMessage,OnUserMessage(user,(void*)parameters[0],TYPE_SERVER,parameters[1],0,except_list));
+ FOREACH_MOD(I_OnUserMessage,OnUserMessage(user,(void*)parameters[0],TYPE_SERVER,text,0,except_list));
return CMD_SUCCESS;
}
char status = 0;
- if ((*parameters[0] == '@') || (*parameters[0] == '%') || (*parameters[0] == '+'))
+ const char* target = parameters[0];
+ if ((*target == '@') || (*target == '%') || (*target == '+'))
{
- status = *parameters[0];
- parameters[0]++;
+ status = *target;
+ target++;
}
- if (parameters[0][0] == '#')
+ if (*target == '#')
{
- chan = ServerInstance->FindChan(parameters[0]);
+ chan = ServerInstance->FindChan(target);
except_list[user] = user->nick;
if (MOD_RESULT) {
return CMD_FAILURE;
}
- parameters[1] = temp.c_str();
+ const char* text = temp.c_str();
/* Check again, a module may have zapped the input string */
if (temp.empty())
return CMD_FAILURE;
}
- FOREACH_MOD(I_OnText,OnText(user,chan,TYPE_CHANNEL,parameters[1],status,except_list));
+ FOREACH_MOD(I_OnText,OnText(user,chan,TYPE_CHANNEL,text,status,except_list));
if (status)
{
if (ServerInstance->Config->UndernetMsgPrefix)
{
- chan->WriteAllExcept(user, false, status, except_list, "PRIVMSG %c%s :%c %s", status, chan->name, status, parameters[1]);
+ chan->WriteAllExcept(user, false, status, except_list, "PRIVMSG %c%s :%c %s", status, chan->name, status, text);
}
else
{
- chan->WriteAllExcept(user, false, status, except_list, "PRIVMSG %c%s :%s", status, chan->name, parameters[1]);
+ chan->WriteAllExcept(user, false, status, except_list, "PRIVMSG %c%s :%s", status, chan->name, text);
}
}
else
{
- chan->WriteAllExcept(user, false, status, except_list, "PRIVMSG %s :%s", chan->name, parameters[1]);
+ chan->WriteAllExcept(user, false, status, except_list, "PRIVMSG %s :%s", chan->name, text);
}
- FOREACH_MOD(I_OnUserMessage,OnUserMessage(user,chan,TYPE_CHANNEL,parameters[1],status,except_list));
+ FOREACH_MOD(I_OnUserMessage,OnUserMessage(user,chan,TYPE_CHANNEL,text,status,except_list));
}
else
{
/* no such nick/channel */
- user->WriteServ("401 %s %s :No such nick/channel",user->nick, parameters[0]);
+ user->WriteServ("401 %s %s :No such nick/channel",user->nick, target);
return CMD_FAILURE;
}
return CMD_SUCCESS;
if (MOD_RESULT) {
return CMD_FAILURE;
}
- parameters[1] = (char*)temp.c_str();
+ const char* text = temp.c_str();
- FOREACH_MOD(I_OnText,OnText(user,dest,TYPE_USER,parameters[1],0,except_list));
+ FOREACH_MOD(I_OnText,OnText(user,dest,TYPE_USER,text,0,except_list));
if (IS_LOCAL(dest))
{
// direct write, same server
- user->WriteTo(dest, "PRIVMSG %s :%s", dest->nick, parameters[1]);
+ user->WriteTo(dest, "PRIVMSG %s :%s", dest->nick, text);
}
- FOREACH_MOD(I_OnUserMessage,OnUserMessage(user,dest,TYPE_USER,parameters[1],0,except_list));
+ FOREACH_MOD(I_OnUserMessage,OnUserMessage(user,dest,TYPE_USER,text,0,except_list));
}
else
{
return new CommandQline(Instance);
}
-CmdResult CommandQline::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandQline::Handle (const char* const* parameters, int pcnt, User *user)
{
if (pcnt >= 3)
{
return new CommandQuit(Instance);
}
-CmdResult CommandQuit::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandQuit::Handle (const char* const* parameters, int pcnt, User *user)
{
std::string quitmsg;
return new CommandRehash(Instance);
}
-CmdResult CommandRehash::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandRehash::Handle (const char* const* parameters, int pcnt, User *user)
{
user->WriteServ("382 %s %s :Rehashing",user->nick,ServerConfig::CleanFilename(ServerInstance->ConfigFileName));
std::string parameter;
return new CommandReloadmodule(Instance);
}
-CmdResult CommandReloadmodule::Handle (const char** parameters, int, User *user)
+CmdResult CommandReloadmodule::Handle (const char* const* parameters, int, User *user)
{
if (ServerInstance->Modules->Unload(parameters[0]))
{
return new CommandRestart(Instance);
}
-CmdResult CommandRestart::Handle (const char** parameters, int, User *user)
+CmdResult CommandRestart::Handle (const char* const* parameters, int, User *user)
{
ServerInstance->Log(DEFAULT,"Restart: %s",user->nick);
if (!ServerInstance->PassCompare(user, ServerInstance->Config->restartpass, parameters[0], ServerInstance->Config->powerhash))
return new CommandRules(Instance);
}
-CmdResult CommandRules::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandRules::Handle (const char* const* parameters, int pcnt, User *user)
{
user->ShowRULES();
return CMD_SUCCESS;
return new CommandServer(Instance);
}
-CmdResult CommandServer::Handle (const char**, int, User *user)
+CmdResult CommandServer::Handle (const char* const*, int, User *user)
{
user->WriteServ("666 %s :You cannot identify as a server, you are a USER. IRC Operators informed.",user->nick);
ServerInstance->SNO->WriteToSnoMask('A', "WARNING: %s attempted to issue a SERVER command and is registered as a user!", user->nick);
return new CommandSquit(Instance);
}
-CmdResult CommandSquit::Handle (const char**, int, User *user)
+CmdResult CommandSquit::Handle (const char* const*, int, User *user)
{
user->WriteServ( "NOTICE %s :Look into loading a linking module (like m_spanningtree) if you want this to do anything useful.", user->nick);
return CMD_FAILURE;
return new CommandStats(Instance);
}
-CmdResult CommandStats::Handle (const char** parameters, int /* pcnt */, User *user)
+CmdResult CommandStats::Handle (const char* const* parameters, int /* pcnt */, User *user)
{
if (IS_LOCAL(user))
{
return new CommandTime(Instance);
}
-CmdResult CommandTime::Handle (const char**, int, User *user)
+CmdResult CommandTime::Handle (const char* const*, int, User *user)
{
struct tm* timeinfo;
time_t local = ServerInstance->Time();
return new CommandTopic(Instance);
}
-CmdResult CommandTopic::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandTopic::Handle (const char* const* parameters, int pcnt, User *user)
{
Channel* Ptr;
/** XXX: This is crap. someone fix this when you have time, to be more useful.
*/
-CmdResult CommandTrace::Handle (const char**, int, User *user)
+CmdResult CommandTrace::Handle (const char* const*, int, User *user)
{
/*for (user_hash::iterator i = ServerInstance->clientlist->begin(); i != ServerInstance->clientlist->end(); i++)
{
return new CommandUnloadmodule(Instance);
}
-CmdResult CommandUnloadmodule::Handle (const char** parameters, int, User *user)
+CmdResult CommandUnloadmodule::Handle (const char* const* parameters, int, User *user)
{
if (ServerInstance->Modules->Unload(parameters[0]))
{
return new CommandUser(Instance);
}
-CmdResult CommandUser::Handle (const char** parameters, int, User *user)
+CmdResult CommandUser::Handle (const char* const* parameters, int, User *user)
{
/* A user may only send the USER command once */
if (!(user->registered & REG_USER))
return new CommandUserhost(Instance);
}
-CmdResult CommandUserhost::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandUserhost::Handle (const char* const* parameters, int pcnt, User *user)
{
std::string retbuf = std::string("302 ") + user->nick + " :";
return new CommandVersion(Instance);
}
-CmdResult CommandVersion::Handle (const char**, int, User *user)
+CmdResult CommandVersion::Handle (const char* const*, int, User *user)
{
user->WriteServ("351 %s :%s",user->nick,ServerInstance->GetVersionString().c_str());
ServerInstance->Config->Send005(user);
return new CommandWallops(Instance);
}
-CmdResult CommandWallops::Handle (const char** parameters, int, User *user)
+CmdResult CommandWallops::Handle (const char* const* parameters, int, User *user)
{
user->WriteWallOps(std::string(parameters[0]));
FOREACH_MOD(I_OnWallops,OnWallops(user,parameters[0]));
whoresults.push_back(wholine);
}
-CmdResult CommandWho::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandWho::Handle (const char* const* parameters, int pcnt, User *user)
{
/*
* XXX - RFC says:
return new CommandWhois(Instance);
}
-CmdResult CommandWhois::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandWhois::Handle (const char* const* parameters, int pcnt, User *user)
{
User *dest;
int userindex = 0;
Instance->Timers->AddTimer(timer);
}
-CmdResult CommandWhowas::Handle (const char** parameters, int, User* user)
+CmdResult CommandWhowas::Handle (const char* const* parameters, int, User* user)
{
/* if whowas disabled in config */
if (ServerInstance->Config->WhoWasGroupSize == 0 || ServerInstance->Config->WhoWasMaxGroups == 0)
return new CommandZline(Instance);
}
-CmdResult CommandZline::Handle (const char** parameters, int pcnt, User *user)
+CmdResult CommandZline::Handle (const char* const* parameters, int pcnt, User *user)
{
std::string target = parameters[0];
joined.append(sequence[end]);
}
-irc::stringjoiner::stringjoiner(const std::string &seperator, const char** sequence, int begin, int end)
+irc::stringjoiner::stringjoiner(const std::string &seperator, const char* const* sequence, int begin, int end)
{
for (int v = begin; v < end; v++)
joined.append(sequence[v]).append(seperator);
return;
}
-void ModeParser::Process(const char** parameters, int pcnt, User *user, bool servermode)
+void ModeParser::Process(const char* const* parameters, int pcnt, User *user, bool servermode)
{
std::string target = parameters[0];
ModeType type = MODETYPE_USER;
void Module::OnLoadModule(Module*, const std::string&) { }
void Module::OnUnloadModule(Module*, const std::string&) { }
void Module::OnBackgroundTimer(time_t) { }
-int Module::OnPreCommand(const std::string&, const char**, int, User *, bool, const std::string&) { return 0; }
-void Module::OnPostCommand(const std::string&, const char**, int, User *, CmdResult, const std::string&) { }
+int Module::OnPreCommand(const std::string&, const char* const*, int, User *, bool, const std::string&) { return 0; }
+void Module::OnPostCommand(const std::string&, const char* const*, int, User *, CmdResult, const std::string&) { }
bool Module::OnCheckReady(User*) { return true; }
int Module::OnUserRegister(User*) { return 0; }
int Module::OnUserPreKick(User*, User*, Channel*, const std::string&) { return 0; }
return match(sliteral.c_str(),spattern.c_str());
}
-CmdResult InspIRCd::CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, User* user)
+CmdResult InspIRCd::CallCommandHandler(const std::string &commandname, const char* const* parameters, int pcnt, User* user)
{
return this->Parser->CallHandler(commandname,parameters,pcnt,user);
}
}
}
-void InspIRCd::SendMode(const char** parameters, int pcnt, User *user)
+void InspIRCd::SendMode(const char* const* parameters, int pcnt, User *user)
{
this->Modes->Process(parameters,pcnt,user,true);
}
this->source = "m_rline.so";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
if (pcnt >= 3)
return 0;
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
if ((command == "GLINE" || command == "KLINE" || command == "ELINE" || command == "ZLINE") && validated)
{
databaseid = Conf.ReadValue("sqloper", "dbid", 0); /* Database ID of a database configured for the service provider module */
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
if ((validated) && (command == "OPER"))
{
syntax = "<nickname>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* target = ServerInstance->FindNick(parameters[0]);
if (target)
return false;
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
irc::string cmd = command.c_str();
this->syntax = "<nick>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* target = ServerInstance->FindNick(parameters[0]);
ssl_cert* cert;
}
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
User *u = NULL;
translation.push_back(TR_END);
}
- CmdResult Handle(const char **parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
char fmtdate[64];
char fmtdate2[64];
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
if (command == "NOTICE" && !validated && pcnt > 1 && user->GetExt("antibear_timewait"))
{
return Version(1,1,0,1,VF_VENDOR,API_VERSION);
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
char data[MAXBUF];
strlcpy(data,original_line.c_str(),MAXBUF);
action = IBLOCK_KILLOPERS;
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
// Don't do anything with unregistered users, or remote ones.
if(!user || (user->registered != REG_ALL) || !IS_LOCAL(user))
* /accept nick1,nick2,nick3 *
* to add 3 nicks and then show your list
*/
- CmdResult Handle(const char** parameters, int pcnt, User* user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User* user)
{
if (pcnt < 1)
{
TRANSLATE4(TR_TEXT,TR_TEXT,TR_TEXT,TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
/* syntax: CBAN #channel time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
this->source = "m_cgiirc.so";
this->syntax = "password client hostname ip";
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
if(user->registered == REG_ALL)
return CMD_FAILURE;
syntax = "<nickname>|<ip>|<hostmask>|<channel>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User *targuser;
Channel *targchan;
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
const char * x = parameters[1];
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
User* dest = ServerInstance->FindNick(parameters[0]);
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
User* dest = ServerInstance->FindNick(parameters[0]);
syntax = "<limit>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
std::string clonesstr = "304 " + std::string(user->nick) + " :CLONES";
this->source = "m_close.so";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
std::map<std::string,int> closed;
return 0;
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User* user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User* user, bool validated, const std::string &original_line)
{
if (command == "PONG")
{
return false;
}
- CmdResult Handle(const char** parameters, int pcnt, User* user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User* user)
{
if (!IS_LOCAL(user))
return CMD_LOCALONLY;
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
Channel* channel = ServerInstance->FindChan(parameters[0]);
std::string reason = ConvToStr("Cycling");
/* XXX we need to fix this so it can work with translation stuff (i.e. move +- into a seperate param */
}
- CmdResult Handle(const char **parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
/* syntax: DCCALLOW [+|-]<nick> (<time>) */
if (!pcnt)
TRANSLATE2(TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
Channel* c = ServerInstance->FindChan(parameters[0]);
if (c && c->HasUser(user))
virtual void OnSyncOtherMetaData(Module* proto, void* opaque, bool displayable = false);
virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata);
virtual int OnStats(char symbol, User* user, string_list &results) = 0;
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line);
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line);
bool AppliesToMe(User* user, FilterResult* filter, int flags);
};
this->syntax = "<filter-definition> <type> <flags> [<gline-duration>] :<reason>";
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
if (pcnt == 1)
{
return 0;
}
-int FilterBase::OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+int FilterBase::OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
flags = 0;
if ((validated == 1) && (IS_LOCAL(user)))
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
std::string servername = pcnt > 1 ? parameters[1] : "*";
syntax = "<modulename> [servermask]";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
std::string servername = pcnt > 1 ? parameters[1] : "*";
syntax = "<modulename> [servermask]";
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
std::string servername = pcnt > 1 ? parameters[1] : "*";
TRANSLATE2(TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
std::string line = "From " + std::string(user->nick) + ": ";
for (int i = 0; i < pcnt; i++)
syntax = "<any-text>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
irc::string parameter("start");
if (pcnt > 0)
redirect_all_immediately = redirect_new_users = false;
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
int n_done = 0;
reason = (pcnt < 4) ? "Please use this server/port instead" : parameters[3];
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
Channel* c = ServerInstance->FindChan(parameters[0]);
std::string line;
syntax.clear();
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
locked = true;
user->WriteServ("988 %s %s :Closed for new connections", user->nick, user->server);
syntax.clear();
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
locked = false;
user->WriteServ("989 %s %s :Open for new connections", user->nick, user->server);
output.append(" NAMESX");
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
irc::string c = command.c_str();
/* We don't actually create a proper command handler class for PROTOCTL,
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
User* target = ServerInstance->FindNick(parameters[0]);
irc::string server;
syntax = "<locked-nick>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* target = ServerInstance->FindNick(parameters[0]);
if (target)
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
/* If the command doesnt appear to be valid, we dont want to mess with it. */
if (!validated)
syntax = "[<servername>]";
}
- CmdResult Handle (const char** parameters, int pcnt, User* user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User* user)
{
return ShowOperMOTD(user);
}
}
- virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, User *user, CmdResult result, const std::string &original_line)
+ virtual void OnPostCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, CmdResult result, const std::string &original_line)
{
if ((NoisyOverride) && (OverriddenMode) && (irc::string(command.c_str()) == "MODE") && (result == CMD_SUCCESS))
{
}
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
MakeHash(user, parameters[0], parameters[1]);
/* NOTE: Don't propagate this across the network!
this->source = "m_randquote.so";
}
- CmdResult Handle (const char** parameters, int pcntl, User *user)
+ CmdResult Handle (const char* const* parameters, int pcntl, User *user)
{
std::string str;
int fsize;
}
}
- CmdResult Handle (const char** parameters, int pcnt, User *user, bool neworder)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user, bool neworder)
{
const char* channame;
const char* username;
TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
return RemoveBase::Handle(parameters, pcnt, user, false);
}
syntax = "<channel> <nick> [<reason>]";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
return RemoveBase::Handle(parameters, pcnt, user, true);
}
* OnPreCommand()
* Intercept the LIST command.
*/
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
/* If the command doesnt appear to be valid, we dont want to mess with it. */
if (!validated)
* HandleList()
* Handle (override) the LIST command.
*/
- int HandleList(const char** parameters, int pcnt, User* user)
+ int HandleList(const char* const* parameters, int pcnt, User* user)
{
int minusers = 0, maxusers = 0;
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* dest = ServerInstance->FindNick(parameters[0]);
if (dest)
syntax = "<target> <modes> {<mode-parameters>}";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
/*
* Handles an SAMODE request. Notifies all +s users.
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* target = ServerInstance->FindNick(parameters[0]);
if (target)
TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* dest = ServerInstance->FindNick(parameters[0]);
Channel* channel = ServerInstance->FindChan(parameters[1]);
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* dest = ServerInstance->FindNick(parameters[0]);
if (dest)
* OnPreCommand()
* Intercept the LIST command.
*/
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
/* If the command doesnt appear to be valid, we dont want to mess with it. */
if (!validated)
TRANSLATE2(TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
size_t len = 0;
for (const char* x = parameters[0]; *x; x++, len++)
TRANSLATE2(TR_TEXT, TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
if (!*parameters[0])
{
TRANSLATE2(TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
time_t idle = ServerInstance->Duration(parameters[0]);
if (idle < 1)
TRANSLATE2(TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
if (!*parameters[0])
{
TRANSLATE2(TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
if (!pcnt)
{
TRANSLATE3(TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
if (!pcnt)
{
return Utils->serverlist.size();
}
-void ModuleSpanningTree::HandleLinks(const char** parameters, int pcnt, User* user)
+void ModuleSpanningTree::HandleLinks(const char* const* parameters, int pcnt, User* user)
{
ShowLinks(Utils->TreeRoot,user,0);
user->WriteServ("365 %s * :End of /LINKS list.",user->nick);
return;
}
-void ModuleSpanningTree::HandleLusers(const char** parameters, int pcnt, User* user)
+void ModuleSpanningTree::HandleLusers(const char* const* parameters, int pcnt, User* user)
{
unsigned int n_users = ServerInstance->Users->UserCount();
}
}
-int ModuleSpanningTree::HandleVersion(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleVersion(const char* const* parameters, int pcnt, User* user)
{
// we've already checked if pcnt > 0, so this is safe
TreeServer* found = Utils->FindServerMask(parameters[0]);
SendingRemoteMessage = false;
}
-int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleConnect(const char* const* parameters, int pcnt, User* user)
{
for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
{
/** Handle LINKS command
*/
- void HandleLinks(const char** parameters, int pcnt, User* user);
+ void HandleLinks(const char* const* parameters, int pcnt, User* user);
/** Handle LUSERS command
*/
- void HandleLusers(const char** parameters, int pcnt, User* user);
+ void HandleLusers(const char* const* parameters, int pcnt, User* user);
/** Show MAP output to a user (recursive)
*/
/** Handle remote MOTD
*/
- int HandleMotd(const char** parameters, int pcnt, User* user);
+ int HandleMotd(const char* const* parameters, int pcnt, User* user);
/** Handle remote ADMIN
*/
- int HandleAdmin(const char** parameters, int pcnt, User* user);
+ int HandleAdmin(const char* const* parameters, int pcnt, User* user);
/** Handle remote STATS
*/
- int HandleStats(const char** parameters, int pcnt, User* user);
+ int HandleStats(const char* const* parameters, int pcnt, User* user);
/** Handle MAP command
*/
- void HandleMap(const char** parameters, int pcnt, User* user);
+ void HandleMap(const char* const* parameters, int pcnt, User* user);
/** Handle SQUIT
*/
- int HandleSquit(const char** parameters, int pcnt, User* user);
+ int HandleSquit(const char* const* parameters, int pcnt, User* user);
/** Handle TIME
*/
- int HandleTime(const char** parameters, int pcnt, User* user);
+ int HandleTime(const char* const* parameters, int pcnt, User* user);
/** Handle remote WHOIS
*/
- int HandleRemoteWhois(const char** parameters, int pcnt, User* user);
+ int HandleRemoteWhois(const char* const* parameters, int pcnt, User* user);
/** Handle remote MODULES
*/
- int HandleModules(const char** parameters, int pcnt, User* user);
+ int HandleModules(const char* const* parameters, int pcnt, User* user);
/** Ping all local servers
*/
/** Handle remote VERSON
*/
- int HandleVersion(const char** parameters, int pcnt, User* user);
+ int HandleVersion(const char* const* parameters, int pcnt, User* user);
/** Handle CONNECT
*/
- int HandleConnect(const char** parameters, int pcnt, User* user);
+ int HandleConnect(const char* const* parameters, int pcnt, User* user);
/** Send out time sync to all servers
*/
** *** MODULE EVENTS ***
**/
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line);
- virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, User *user, CmdResult result, const std::string &original_line);
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line);
+ virtual void OnPostCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, CmdResult result, const std::string &original_line);
virtual void OnGetServerDescription(const std::string &servername,std::string &description);
virtual void OnUserInvite(User* source,User* dest,Channel* channel, time_t);
virtual void OnPostLocalTopicChange(User* user, Channel* chan, const std::string &topic);
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleAdmin(const char* const* parameters, int pcnt, User* user)
{
if (pcnt > 0)
{
// and divisons, we instead render the map onto a backplane of characters
// (a character matrix), then draw the branches as a series of "L" shapes
// from the nodes. This is not only friendlier on CPU it uses less stack.
-void ModuleSpanningTree::HandleMap(const char** parameters, int pcnt, User* user)
+void ModuleSpanningTree::HandleMap(const char* const* parameters, int pcnt, User* user)
{
// This array represents a virtual screen which we will
// "scratch" draw to, as the console device of an irc
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::HandleModules(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleModules(const char* const* parameters, int pcnt, User* user)
{
if (pcnt > 0)
{
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleMotd(const char* const* parameters, int pcnt, User* user)
{
if (pcnt > 0)
{
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::HandleSquit(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleSquit(const char* const* parameters, int pcnt, User* user)
{
TreeServer* s = Utils->FindServerMask(parameters[0]);
if (s)
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleStats(const char* const* parameters, int pcnt, User* user)
{
if (pcnt > 1)
{
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::HandleTime(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleTime(const char* const* parameters, int pcnt, User* user)
{
if ((IS_LOCAL(user)) && (pcnt))
{
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::HandleRemoteWhois(const char** parameters, int pcnt, User* user)
+int ModuleSpanningTree::HandleRemoteWhois(const char* const* parameters, int pcnt, User* user)
{
if ((IS_LOCAL(user)) && (pcnt > 1))
{
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-void ModuleSpanningTree::OnPostCommand(const std::string &command, const char** parameters, int pcnt, User *user, CmdResult result, const std::string &original_line)
+void ModuleSpanningTree::OnPostCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, CmdResult result, const std::string &original_line)
{
if ((result == CMD_SUCCESS) && (ServerInstance->IsValidModuleCommand(command, pcnt, user)))
{
/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
-int ModuleSpanningTree::OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+int ModuleSpanningTree::OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
/* If the command doesnt appear to be valid, we dont want to mess with it. */
if (!validated)
syntax = "<remote-server-mask> <target-server-mask>";
}
-CmdResult cmd_rconnect::Handle (const char** parameters, int pcnt, User *user)
+CmdResult cmd_rconnect::Handle (const char* const* parameters, int pcnt, User *user)
{
if (IS_LOCAL(user))
{
SpanningTreeUtilities* Utils; /* Utility class */
public:
cmd_rconnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util);
- CmdResult Handle (const char** parameters, int pcnt, User *user);
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user);
};
#endif
syntax = "<remote-server-mask> [target-server-mask]";
}
-CmdResult cmd_rsquit::Handle (const char** parameters, int pcnt, User *user)
+CmdResult cmd_rsquit::Handle (const char* const* parameters, int pcnt, User *user)
{
if (IS_LOCAL(user))
{
SpanningTreeUtilities* Utils; /* Utility class */
public:
cmd_rsquit (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util);
- CmdResult Handle (const char** parameters, int pcnt, User *user);
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user);
void NoticeUser(User* user, const std::string &msg);
};
TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User *user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User *user)
{
/* syntax: svshold nickname time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle(const char** parameters, int pcnt, User* user)
+ CmdResult Handle(const char* const* parameters, int pcnt, User* user)
{
User* dest = ServerInstance->FindNick(parameters[0]);
}
}
- virtual void OnPostCommand(const std::string &command, const char **params, int pcnt, User *user, CmdResult result, const std::string &original_line)
+ virtual void OnPostCommand(const std::string &command, const char* const* params, int pcnt, User *user, CmdResult result, const std::string &original_line)
{
if ((command != "OPER") || (result != CMD_SUCCESS))
return;
syntax = "<nickname>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* dest = ServerInstance->FindNick(parameters[0]);
if (dest)
this->source = "m_testcommand.so";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
user->WriteServ("NOTICE %s :*** DALNet had nothing to do with it.", user->nick);
return CMD_FAILURE;
TRANSLATE4(TR_TEXT, TR_TEXT, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
Channel* channel = ServerInstance->FindChan(parameters[0]);
if (channel)
this->syntax = "<mask>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
float n_counted = 0;
float n_matched = 0;
ServerInstance->Modules->SetPriority(this, I_OnUserList, PRIO_BEFORE, &namesx);
}
- virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, User *user, bool validated, const std::string &original_line)
+ virtual int OnPreCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, bool validated, const std::string &original_line)
{
irc::string c = command.c_str();
/* We don't actually create a proper command handler class for PROTOCTL,
TRANSLATE3(TR_NICK, TR_TEXT, TR_END);
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
User* u = ServerInstance->FindNick(parameters[0]);
Channel* c = ServerInstance->FindChan(parameters[1]);
syntax = "<nick>{,<nick>}";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
std::string retbuf = std::string("340 ") + user->nick + " :";
syntax = "<username> <password>";
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
ConfigReader *Conf = new ConfigReader(ServerInstance);
TRANSLATE3(TR_NICK, TR_TEXT, TR_END); /* we watch for a nick. not a UID. */
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
if (!ServerInstance->ULine(user->server))
return CMD_FAILURE;
TRANSLATE2(TR_TEXT, TR_END); /* we watch for a nick. not a UID. */
}
- CmdResult Handle (const char** parameters, int pcnt, User *user)
+ CmdResult Handle (const char* const* parameters, int pcnt, User *user)
{
if (!pcnt)
{
projects / user / henk / code / inspircd.git / commitdiff