* 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 std::vector<std::string>& parameters, User* user, Command** cmd = NULL);
+ CmdResult CallHandler(const std::string& commandname, const CommandBase::Params& parameters, User* user, Command** cmd = NULL);
/** Get the handler function for a command.
* @param commandname The command required. Always use uppercase for this parameter.
* command handler for each entry on the list. When this occurs, the caller should return without doing anything,
* otherwise it should continue into its main section of code.
*/
- static bool LoopCall(User* user, Command* handler, const std::vector<std::string>& parameters, unsigned int splithere, int extra = -1, bool usemax = true);
+ static bool LoopCall(User* user, Command* handler, const CommandBase::Params& parameters, unsigned int splithere, int extra = -1, bool usemax = true);
/** Take a raw input buffer from a recvq, and process it on behalf of a user.
* @param buffer The buffer line to process
* @param custom_translator Used to translate the parameter if the translation type is TR_CUSTOM, if NULL, TR_CUSTOM will act like TR_TEXT
* @return dest The output string
*/
- static std::string TranslateUIDs(const std::vector<TranslateType>& to, const std::vector<std::string>& source, bool prefix_final = false, CommandBase* custom_translator = NULL);
+ static std::string TranslateUIDs(const std::vector<TranslateType>& to, const CommandBase::Params& source, bool prefix_final = false, CommandBase* custom_translator = NULL);
};
/** 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 std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CoreExport CommandBase : public ServiceProvider
{
public:
+ typedef std::vector<std::string> Params;
+
/** User flags needed to execute the command or 0
*/
unsigned char flags_needed;
*/
CommandBase(Module* me, const std::string& cmd, unsigned int minpara = 0, unsigned int maxpara = 0);
- virtual RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
+ virtual RouteDescriptor GetRouting(User* user, const CommandBase::Params& parameters);
/** Encode a parameter for server->server transmission.
* Used for parameters for which the translation type is TR_CUSTOM.
* @param user The user who issued the command.
* @return Return CMD_SUCCESS on success, or CMD_FAILURE on failure.
*/
- virtual CmdResult Handle(const std::vector<std::string>& parameters, User* user) = 0;
+ virtual CmdResult Handle(User* user, const Params& parameters) = 0;
/** Register this object in the CommandParser
*/
public:
SplitCommand(Module* me, const std::string &cmd, unsigned int minpara = 0, unsigned int maxpara = 0)
: Command(me, cmd, minpara, maxpara) {}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- virtual CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
- virtual CmdResult HandleRemote(const std::vector<std::string>& parameters, RemoteUser* user);
- virtual CmdResult HandleServer(const std::vector<std::string>& parameters, FakeUser* user);
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ virtual CmdResult HandleLocal(LocalUser* user, const Params& parameters);
+ virtual CmdResult HandleRemote(RemoteUser* user, const Params& parameters);
+ virtual CmdResult HandleServer(FakeUser* user, const Params& parameters);
};
/** Shortcut macros for defining translation lists
#include "cull_list.h"
#include "extensible.h"
#include "fileutils.h"
+#include "ctables.h"
#include "numerics.h"
#include "numeric.h"
#include "uid.h"
#include "logger.h"
#include "usermanager.h"
#include "socket.h"
-#include "ctables.h"
#include "command_parse.h"
#include "mode.h"
#include "socketengine.h"
* @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 ModResult OnPreCommand(std::string &command, std::vector<std::string>& parameters, LocalUser *user, bool validated, const std::string &original_line);
+ virtual ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* 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(Command* command, const std::vector<std::string>& parameters, LocalUser* user, CmdResult result, const std::string& original_line);
+ virtual void OnPostCommand(Command* command, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, const std::string& original_line);
/** Called when a user is first connecting, prior to starting DNS lookups, checking initial
* connect class, or accepting any commands.
{
}
- virtual void OnSASLAuth(const parameterlist& params) = 0;
+ virtual void OnSASLAuth(const CommandBase::Params& params) = 0;
};
/** Parameters of the numeric
*/
- std::vector<std::string> params;
+ CommandBase::Params params;
/** Source server of the numeric, if NULL (the default) then it is the local server
*/
/** Get the parameters of the numeric
* @return Parameters of the numeric as a const vector of strings
*/
- const std::vector<std::string>& GetParams() const { return params; }
+ const CommandBase::Params& GetParams() const { return params; }
/** Get the parameters of the numeric
* @return Parameters of the numeric as a vector of strings
*/
- std::vector<std::string>& GetParams() { return params; }
+ CommandBase::Params& GetParams() { return params; }
};
class User;
-typedef std::vector<std::string> parameterlist;
-
class ProtocolServer
{
public:
* and the message was sent, false if it was not found.
* ENCAP (should) be used instead of creating new protocol messages for easier third party application support.
*/
- virtual bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const parameterlist& params, User* source = NULL) { return false; }
+ virtual bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const CommandBase::Params& params, User* source = NULL) { return false; }
/** Send an ENCAP message to all servers.
* See the protocol documentation for the purpose of ENCAP.
* or NULL which is equivalent to the local server
* @param omit If non-NULL the message won't be sent in the direction of this server, useful for forwarding messages
*/
- virtual void BroadcastEncap(const std::string& cmd, const parameterlist& params, User* source = NULL, User* omit = NULL) { }
+ virtual void BroadcastEncap(const std::string& cmd, const CommandBase::Params& params, User* source = NULL, User* omit = NULL) { }
/** Send metadata for a channel to other linked servers.
* @param chan The channel to send metadata for
return TimingSafeCompare(data, input);
}
-bool CommandParser::LoopCall(User* user, Command* handler, const std::vector<std::string>& parameters, unsigned int splithere, int extra, bool usemax)
+bool CommandParser::LoopCall(User* user, Command* handler, const CommandBase::Params& parameters, unsigned int splithere, int extra, bool usemax)
{
if (splithere >= parameters.size())
return false;
{
if ((!check_dupes) || (dupes.insert(item).second))
{
- std::vector<std::string> new_parameters(parameters);
+ CommandBase::Params new_parameters(parameters);
new_parameters[splithere] = item;
if (extra >= 0)
new_parameters[extra] = item;
}
- CmdResult result = handler->Handle(new_parameters, user);
+ CmdResult result = handler->Handle(user, new_parameters);
if (localuser)
{
// Run the OnPostCommand hook with the last parameter (original line) being empty
// calls a handler function for a command
-CmdResult CommandParser::CallHandler(const std::string& commandname, const std::vector<std::string>& parameters, User* user, Command** cmd)
+CmdResult CommandParser::CallHandler(const std::string& commandname, const CommandBase::Params& parameters, User* user, Command** cmd)
{
CommandMap::iterator n = cmdlist.find(commandname);
{
if (cmd)
*cmd = n->second;
- return n->second->Handle(parameters,user);
+ return n->second->Handle(user, parameters);
}
}
}
void CommandParser::ProcessCommand(LocalUser *user, std::string &cmd)
{
- std::vector<std::string> command_p;
+ CommandBase::Params command_p;
irc::tokenstream tokens(cmd);
std::string command, token;
tokens.GetToken(command);
*/
// Iterator to the last parameter that will be kept
- const std::vector<std::string>::iterator lastkeep = command_p.begin() + (handler->max_params - 1);
+ const CommandBase::Params::iterator lastkeep = command_p.begin() + (handler->max_params - 1);
// Iterator to the first excess parameter
- const std::vector<std::string>::iterator firstexcess = lastkeep + 1;
+ const CommandBase::Params::iterator firstexcess = lastkeep + 1;
// Append all excess parameter(s) to the last parameter, seperated by spaces
- for (std::vector<std::string>::const_iterator i = firstexcess; i != command_p.end(); ++i)
+ for (CommandBase::Params::const_iterator i = firstexcess; i != command_p.end(); ++i)
{
lastkeep->push_back(' ');
lastkeep->append(*i);
/*
* WARNING: be careful, the user may be deleted soon
*/
- CmdResult result = handler->Handle(command_p, user);
+ CmdResult result = handler->Handle(user, command_p);
FOREACH_MOD(OnPostCommand, (handler, command_p, user, result, cmd));
}
{
}
-RouteDescriptor CommandBase::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandBase::GetRouting(User* user, const Params& parameters)
{
return ROUTE_LOCALONLY;
}
#include "inspircd.h"
-CmdResult SplitCommand::Handle(const std::vector<std::string>& parms, User* u)
+CmdResult SplitCommand::Handle(User* user, const Params& parameters)
{
- if (IS_LOCAL(u))
- return HandleLocal(parms, IS_LOCAL(u));
- if (IS_REMOTE(u))
- return HandleRemote(parms, IS_REMOTE(u));
- if (IS_SERVER(u))
- return HandleServer(parms, IS_SERVER(u));
- ServerInstance->Logs->Log("COMMAND", LOG_DEFAULT, "Unknown user type in command (uuid=%s)!", u->uuid.c_str());
+ switch (user->usertype)
+ {
+ case USERTYPE_LOCAL:
+ return HandleLocal(static_cast<LocalUser*>(user), parameters);
+
+ case USERTYPE_REMOTE:
+ return HandleRemote(static_cast<RemoteUser*>(user), parameters);
+
+ case USERTYPE_SERVER:
+ return HandleServer(static_cast<FakeUser*>(user), parameters);
+ }
+
+ ServerInstance->Logs->Log("COMMAND", LOG_DEFAULT, "Unknown user type %d in command (uuid=%s)!",
+ user->usertype, user->uuid.c_str());
return CMD_INVALID;
}
-CmdResult SplitCommand::HandleLocal(const std::vector<std::string>&, LocalUser*)
+CmdResult SplitCommand::HandleLocal(LocalUser* user, const Params& parameters)
{
return CMD_INVALID;
}
-CmdResult SplitCommand::HandleRemote(const std::vector<std::string>&, RemoteUser*)
+CmdResult SplitCommand::HandleRemote(RemoteUser* user, const Params& parameters)
{
return CMD_INVALID;
}
-CmdResult SplitCommand::HandleServer(const std::vector<std::string>&, FakeUser*)
+CmdResult SplitCommand::HandleServer(FakeUser* user, const Params& parameters)
{
return CMD_INVALID;
}
/** Handle /INVITE
*/
-CmdResult CommandInvite::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandInvite::Handle(User* user, const Params& parameters)
{
ModResult MOD_RESULT;
return CMD_SUCCESS;
}
-RouteDescriptor CommandInvite::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandInvite::GetRouting(User* user, const Params& parameters)
{
return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST);
}
/** Handle /JOIN
*/
-CmdResult CommandJoin::HandleLocal(const std::vector<std::string>& parameters, LocalUser *user)
+CmdResult CommandJoin::HandleLocal(LocalUser* user, const Params& parameters)
{
if (parameters.size() > 1)
{
/** Handle /KICK
*/
-CmdResult CommandKick::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandKick::Handle(User* user, const Params& parameters)
{
Channel* c = ServerInstance->FindChan(parameters[0]);
User* u;
return CMD_SUCCESS;
}
-RouteDescriptor CommandKick::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandKick::GetRouting(User* user, const Params& parameters)
{
return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST);
}
/** Handle /NAMES
*/
-CmdResult CommandNames::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+CmdResult CommandNames::HandleLocal(LocalUser* user, const Params& parameters)
{
Channel* c;
Penalty = 2;
}
-CmdResult CommandTopic::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+CmdResult CommandTopic::HandleLocal(LocalUser* user, const Params& parameters)
{
Channel* c = ServerInstance->FindChan(parameters[0]);
if (!c)
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /JOIN.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /TOPIC.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /NAMES.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
/** Spool the NAMES list for a given channel to the given user
* @param user User to spool the NAMES list to
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Channel mode +b
/** Handle /ADMIN
*/
-CmdResult CommandAdmin::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandAdmin::Handle(User* user, const Params& parameters)
{
if (parameters.size() > 0 && parameters[0] != ServerInstance->Config->ServerName)
return CMD_SUCCESS;
/** Handle /COMMANDS
*/
-CmdResult CommandCommands::Handle (const std::vector<std::string>&, User *user)
+CmdResult CommandCommands::Handle(User* user, const Params& parameters)
{
const CommandParser::CommandMap& commands = ServerInstance->Parser.GetCommands();
std::vector<std::string> list;
/** Handle /INFO
*/
-CmdResult CommandInfo::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandInfo::Handle(User* user, const Params& parameters)
{
if (parameters.size() > 0 && parameters[0] != ServerInstance->Config->ServerName)
return CMD_SUCCESS;
/** Handle /MODULES
*/
-CmdResult CommandModules::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandModules::Handle(User* user, const Params& parameters)
{
// Don't ask remote servers about their modules unless the local user asking is an oper
// 2.0 asks anyway, so let's handle that the same way
/** Handle /MOTD
*/
-CmdResult CommandMotd::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandMotd::Handle(User* user, const Params& parameters)
{
if (parameters.size() > 0 && parameters[0] != ServerInstance->Config->ServerName)
{
syntax = "[<servername>]";
}
-CmdResult CommandTime::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandTime::Handle(User* user, const Params& parameters)
{
if (parameters.size() > 0 && parameters[0] != ServerInstance->Config->ServerName)
return CMD_SUCCESS;
syntax = "[<servername>]";
}
-CmdResult CommandVersion::Handle (const std::vector<std::string>&, User *user)
+CmdResult CommandVersion::Handle(User* user, const Params& parameters)
{
std::string version = ServerInstance->GetVersionString((user->IsOper()));
user->WriteNumeric(RPL_VERSION, version);
#include "inspircd.h"
#include "core_info.h"
-RouteDescriptor ServerTargetCommand::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor ServerTargetCommand::GetRouting(User* user, const Params& parameters)
{
// Parameter must be a server name, not a nickname or uuid
if ((!parameters.empty()) && (parameters[0].find('.') != std::string::npos))
{
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /ADMIN.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /COMMANDS.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /INFO.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /MODULES.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /MOTD.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /TIME.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /VERSION.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
};
class IsonReplyBuilder : public Numeric::Builder<' ', true>
/** Handle /ISON
*/
-CmdResult CommandIson::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+CmdResult CommandIson::HandleLocal(LocalUser* user, const Params& parameters)
{
IsonReplyBuilder reply(user);
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /LIST
*/
-CmdResult CommandList::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandList::Handle(User* user, const Params& parameters)
{
// C: Searching based on creation time, via the "C<val" and "C>val" modifiers
// to search for a channel creation time that is lower or higher than val
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /LOADMODULE
*/
-CmdResult CommandLoadmodule::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandLoadmodule::Handle(User* user, const Params& parameters)
{
if (ServerInstance->Modules->Load(parameters[0]))
{
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
-CmdResult CommandUnloadmodule::Handle(const std::vector<std::string>& parameters, User* user)
+CmdResult CommandUnloadmodule::Handle(User* user, const Params& parameters)
{
if (!ServerInstance->Config->ConfValue("security")->getBool("allowcoreunload") &&
InspIRCd::Match(parameters[0], "core_*.so", ascii_case_insensitive_map))
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /LUSERS
*/
-CmdResult CommandLusers::Handle (const std::vector<std::string>&, User *user)
+CmdResult CommandLusers::Handle(User* user, const Params& parameters)
{
unsigned int n_users = ServerInstance->Users->RegisteredUserCount();
ProtocolInterface::ServerList serverlist;
/** Handle /DIE
*/
-CmdResult CommandDie::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandDie::Handle(User* user, const Params& parameters)
{
if (DieRestart::CheckPass(user, parameters[0], "diepass"))
{
/** Handle /KILL
*/
-CmdResult CommandKill::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandKill::Handle(User* user, const Params& parameters)
{
/* Allow comma seperated lists of users for /KILL (thanks w00t) */
if (CommandParser::LoopCall(user, this, parameters, 0))
return CMD_SUCCESS;
}
-RouteDescriptor CommandKill::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandKill::GetRouting(User* user, const Params& parameters)
{
// FindNick() doesn't work here because we quit the target user in Handle() which
// removes it from the nicklist, so we check lastuuid: if it's empty then this KILL
syntax = "<username> <password>";
}
-CmdResult CommandOper::HandleLocal(const std::vector<std::string>& parameters, LocalUser *user)
+CmdResult CommandOper::HandleLocal(LocalUser* user, const Params& parameters)
{
bool match_login = false;
bool match_pass = false;
syntax = "[<servermask>]";
}
-CmdResult CommandRehash::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandRehash::Handle(User* user, const Params& parameters)
{
std::string param = parameters.size() ? parameters[0] : "";
syntax = "<server>";
}
-CmdResult CommandRestart::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandRestart::Handle(User* user, const Params& parameters)
{
ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Restart: %s", user->nick.c_str());
if (DieRestart::CheckPass(user, parameters[0], "restartpass"))
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /KILL.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
void EncodeParameter(std::string& param, unsigned int index) CXX11_OVERRIDE;
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /REHASH.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /RESTART
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleMessage(const std::vector<std::string>& parameters, User* user, MessageType mt);
+ CmdResult HandleMessage(User* user, const CommandBase::Params& parameters, MessageType mt);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
// This is handled by the OnUserPostMessage hook to split the LoopCall pieces
}
}
-CmdResult MessageCommandBase::HandleMessage(const std::vector<std::string>& parameters, User* user, MessageType mt)
+CmdResult MessageCommandBase::HandleMessage(User* user, const CommandBase::Params& parameters, MessageType mt)
{
User *dest;
Channel *chan;
{
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
- return HandleMessage(parameters, user, MT);
+ return HandleMessage(user, parameters, MT);
}
};
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
namespace ReloadModule
}
};
-CmdResult CommandReloadmodule::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandReloadmodule::Handle(User* user, const Params& parameters)
{
Module* m = ServerInstance->Modules->Find(parameters[0]);
if (m == creator)
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
if ((parameters.size() > 1) && (parameters[1].find('.') != std::string::npos))
return ROUTE_UNICAST(parameters[1]);
return;
}
-CmdResult CommandStats::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandStats::Handle(User* user, const Params& parameters)
{
if (parameters.size() > 1 && parameters[1] != ServerInstance->Config->ServerName)
{
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
/*
* This is handled by the server linking module, if necessary. Do not remove this stub.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
user->WriteNumeric(RPL_LINKS, ServerInstance->Config->ServerName, ServerInstance->Config->ServerName, InspIRCd::Format("0 %s", ServerInstance->Config->ServerDesc.c_str()));
user->WriteNumeric(RPL_ENDOFLINKS, '*', "End of /LINKS list.");
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (user->registered == REG_ALL)
{
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
user->WriteNotice("Look into loading a linking module (like m_spanningtree) if you want this to do anything useful.");
return CMD_FAILURE;
/** Handle /AWAY
*/
-CmdResult CommandAway::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandAway::Handle(User* user, const Params& parameters)
{
ModResult MOD_RESULT;
return CMD_SUCCESS;
}
-RouteDescriptor CommandAway::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandAway::GetRouting(User* user, const Params& parameters)
{
return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST);
}
memset(&sent, 0, sizeof(sent));
}
-CmdResult CommandMode::Handle(const std::vector<std::string>& parameters, User* user)
+CmdResult CommandMode::Handle(User* user, const Params& parameters)
{
const std::string& target = parameters[0];
Channel* targetchannel = ServerInstance->FindChan(target);
return CMD_SUCCESS;
}
-RouteDescriptor CommandMode::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandMode::GetRouting(User* user, const Params& parameters)
{
return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST);
}
* for the client introduction code in here, youre in the wrong place.
* You need to look in the spanningtree module for this!
*/
-CmdResult CommandNick::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+CmdResult CommandNick::HandleLocal(LocalUser* user, const Params& parameters)
{
std::string oldnick = user->nick;
std::string newnick = parameters[0];
syntax = "<channel>{,<channel>} [<reason>]";
}
-CmdResult CommandPart::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandPart::Handle(User* user, const Params& parameters)
{
std::string reason;
if (parameters.size() > 1)
return CMD_SUCCESS;
}
-RouteDescriptor CommandPart::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandPart::GetRouting(User* user, const Params& parameters)
{
return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST);
}
syntax = "[<message>]";
}
-CmdResult CommandQuit::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandQuit::Handle(User* user, const Params& parameters)
{
std::string quitmsg;
if (parameters.empty())
return CMD_SUCCESS;
}
-RouteDescriptor CommandQuit::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandQuit::GetRouting(User* user, const Params& parameters)
{
return (IS_LOCAL(user) ? ROUTE_LOCALONLY : ROUTE_BROADCAST);
}
syntax = "<username> <localhost> <remotehost> <realname>";
}
-CmdResult CommandUser::HandleLocal(const std::vector<std::string>& parameters, LocalUser *user)
+CmdResult CommandUser::HandleLocal(LocalUser* user, const Params& parameters)
{
/* A user may only send the USER command once */
if (!(user->registered & REG_USER))
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
// Check to make sure they haven't registered -- Fix by FCS
if (user->registered == REG_ALL)
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
user->WriteServ("PONG %s :%s", ServerInstance->Config->ServerName.c_str(), parameters[0].c_str());
return CMD_SUCCESS;
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
// set the user as alive so they survive to next ping
LocalUser* localuser = IS_LOCAL(user);
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandMode : public Command
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /NICK.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /PART.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /QUIT.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /USER.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
/** Run the OnUserRegister hook if the user has sent both NICK and USER. Called after an unregistered user
* successfully executes the USER or the NICK command.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
-CmdResult CommandUserhost::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandUserhost::Handle(User* user, const Params& parameters)
{
const bool has_privs = user->HasPrivPermission("users/auspex");
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
};
-CmdResult CommandWallops::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandWallops::Handle(User* user, const Params& parameters)
{
std::string wallop("WALLOPS :");
wallop.append(parameters[0]);
// A user specified label for the WHOX response.
std::string whox_querytype;
- WhoData(const std::vector<std::string>& parameters)
+ WhoData(const CommandBase::Params& parameters)
: whox(false)
{
// Find the matchtext and swap the 0 for a * so we can use InspIRCd::Match on it.
/** Sends a WHO reply to a user. */
void SendWhoLine(LocalUser* user, const std::vector<std::string>& parameters, Membership* memb, User* u, WhoData& data);
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
};
template<> User* CommandWho::GetUser(UserManager::OperList::const_iterator& t) { return *t; }
data.results.push_back(wholine);
}
-CmdResult CommandWho::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+CmdResult CommandWho::HandleLocal(LocalUser* user, const Params& parameters)
{
WhoData data(parameters);
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE;
- CmdResult HandleRemote(const std::vector<std::string>& parameters, RemoteUser* target) CXX11_OVERRIDE;
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE;
+ CmdResult HandleRemote(RemoteUser* target, const Params& parameters) CXX11_OVERRIDE;
};
class WhoisNumericSink
whois.SendLine(RPL_ENDOFWHOIS, "End of /WHOIS list.");
}
-CmdResult CommandWhois::HandleRemote(const std::vector<std::string>& parameters, RemoteUser* target)
+CmdResult CommandWhois::HandleRemote(RemoteUser* target, const Params& parameters)
{
if (parameters.size() < 2)
return CMD_FAILURE;
return CMD_SUCCESS;
}
-CmdResult CommandWhois::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
+CmdResult CommandWhois::HandleLocal(LocalUser* user, const Params& parameters)
{
User *dest;
unsigned int userindex = 0;
Penalty = 2;
}
-CmdResult CommandWhowas::Handle (const std::vector<std::string>& parameters, User* user)
+CmdResult CommandWhowas::Handle(User* user, const Params& parameters)
{
/* if whowas disabled in config */
if (!manager.IsEnabled())
/** Handle /ELINE
*/
-CmdResult CommandEline::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandEline::Handle(User* user, const Params& parameters)
{
std::string target = parameters[0];
/** Handle /GLINE
*/
-CmdResult CommandGline::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandGline::Handle(User* user, const Params& parameters)
{
std::string target = parameters[0];
/** Handle /KLINE
*/
-CmdResult CommandKline::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandKline::Handle(User* user, const Params& parameters)
{
std::string target = parameters[0];
syntax = "<nick> [<duration> :<reason>]";
}
-CmdResult CommandQline::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandQline::Handle(User* user, const Params& parameters)
{
if (parameters.size() >= 3)
{
syntax = "<ipmask> [<duration> :<reason>]";
}
-CmdResult CommandZline::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandZline::Handle(User* user, const Params& parameters)
{
std::string target = parameters[0];
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /GLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /KLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /QLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
/** Handle /ZLINE.
* @param user The user issuing the command
* @return A value from CmdResult to indicate command success or failure.
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
void Module::OnLoadModule(Module*) { DetachEvent(I_OnLoadModule); }
void Module::OnUnloadModule(Module*) { DetachEvent(I_OnUnloadModule); }
void Module::OnBackgroundTimer(time_t) { DetachEvent(I_OnBackgroundTimer); }
-ModResult Module::OnPreCommand(std::string&, std::vector<std::string>&, LocalUser*, bool, const std::string&) { DetachEvent(I_OnPreCommand); return MOD_RES_PASSTHRU; }
-void Module::OnPostCommand(Command*, const std::vector<std::string>&, LocalUser*, CmdResult, const std::string&) { DetachEvent(I_OnPostCommand); }
+ModResult Module::OnPreCommand(std::string&, CommandBase::Params&, LocalUser*, bool, const std::string&) { DetachEvent(I_OnPreCommand); return MOD_RES_PASSTHRU; }
+void Module::OnPostCommand(Command*, const CommandBase::Params&, LocalUser*, CmdResult, const std::string&) { DetachEvent(I_OnPostCommand); }
void Module::OnUserInit(LocalUser*) { DetachEvent(I_OnUserInit); }
ModResult Module::OnCheckReady(LocalUser*) { DetachEvent(I_OnCheckReady); return MOD_RES_PASSTHRU; }
ModResult Module::OnUserRegister(LocalUser*) { DetachEvent(I_OnUserRegister); return MOD_RES_PASSTHRU; }
return Version("Provides the ability to abbreviate commands a-la BBC BASIC keywords.",VF_VENDOR);
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
/* Command is already validated, has a length of 0, or last character is not a . */
if (validated || command.empty() || *command.rbegin() != '.')
return word;
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
/* If theyre not registered yet, we dont want
* to know.
}
irc::tokenstream ss(result);
- std::vector<std::string> pars;
+ CommandBase::Params pars;
std::string command, token;
ss.GetToken(command);
flags_needed = 'o';
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
const std::string fmtdate = InspIRCd::TimeString(ServerInstance->Time(), "%Y-%m-%d %H:%M:%S", true);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_BCAST;
}
action = IBLOCK_KILLOPERS;
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
// Don't do anything with unregistered users
if (user->registered != REG_ALL)
* /accept nick1,nick2,nick3,*
* to add 3 nicks and then show your list
*/
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (CommandParser::LoopCall(user, this, parameters, 0))
return CMD_SUCCESS;
return (RemoveAccept(user, action.first) ? CMD_SUCCESS : CMD_FAILURE);
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
// There is a list in parameters[0] in two cases:
// Either when the source is remote, this happens because 2.0 servers send comma seperated uuid lists,
works_before_reg = true;
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
if (user->registered != REG_ALL)
holdext.set(user, 1);
flags_needed = 'o'; this->syntax = "<channel> [<duration> :<reason>]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
/* syntax: CBAN #channel time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
return ROUTE_LOCALONLY; // spanningtree will send ADDLINE
this->syntax = "password gateway hostname ip";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
if (user->registered == REG_ALL)
return CMD_FAILURE;
return ret;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters.size() > 1 && parameters[1] != ServerInstance->Config->ServerName)
return CMD_SUCCESS;
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
if ((parameters.size() > 1) && (parameters[1].find('.') != std::string::npos))
return ROUTE_OPT_UCAST(parameters[1]);
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters[1].length() > ServerInstance->Config->Limits.MaxHost)
{
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
force_manual_route = true;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
Channel* chan = activechan = ServerInstance->FindChan(parameters[0]);
if (!chan)
// The idea is that by the time our QUITs reach the next hop, it has already removed all their
// clients from the channel, meaning victims on other servers won't see the victims on this
// server quitting.
- std::vector<std::string> eparams;
+ CommandBase::Params eparams;
eparams.push_back(chan->name);
eparams.push_back(method);
eparams.push_back(":");
syntax = "<host>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class ModuleCloaking : public Module
}
};
-CmdResult CommandCloak::Handle(const std::vector<std::string> ¶meters, User *user)
+CmdResult CommandCloak::Handle(User* user, const Params& parameters)
{
ModuleCloaking* mod = (ModuleCloaking*)(Module*)creator;
irc::sockets::sockaddrs sa;
flags_needed = 'o'; syntax = "<limit>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
std::string clonesstr = "CLONES ";
flags_needed = 'o';
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* src) CXX11_OVERRIDE
+ CmdResult Handle(User* src, const Params& parameters) CXX11_OVERRIDE
{
std::map<std::string,int> closed;
std::string buf;
irc::spacesepstream ss(ThisModes);
- std::vector<std::string> modes;
+ CommandBase::Params modes;
modes.push_back(user->nick);
// split ThisUserModes into modes and mode params
return MOD_RES_PASSTHRU;
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser* user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
if (command == "PONG")
{
syntax = "<user> <password>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
const std::string userHost = user->ident + "@" + user->GetRealHost();
const std::string userIP = user->ident + "@" + user->GetIPString();
Penalty = 3; syntax = "<channel> :[reason]";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
Channel* channel = ServerInstance->FindChan(parameters[0]);
std::string reason = "Cycling";
/* XXX we need to fix this so it can work with translation stuff (i.e. move +- into a seperate param */
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
/* syntax: DCCALLOW [+|-]<nick> (<time>) */
if (!parameters.size())
return CMD_FAILURE;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o';
this->syntax = "<filter-definition> <action> <flags> [<duration>] :<reason>";
}
- CmdResult Handle(const std::vector<std::string>& , User* ) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
void OnSyncNetwork(ProtocolInterface::Server& server) CXX11_OVERRIDE;
void OnDecodeMetaData(Extensible* target, const std::string &extname, const std::string &extdata) CXX11_OVERRIDE;
ModResult OnStats(Stats::Context& stats) CXX11_OVERRIDE;
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE;
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE;
void OnUnloadModule(Module* mod) CXX11_OVERRIDE;
bool AppliesToMe(User* user, FilterResult* filter, int flags);
void ReadFilters();
static std::string FilterActionToString(FilterAction fa);
};
-CmdResult CommandFilter::Handle(const std::vector<std::string> ¶meters, User *user)
+CmdResult CommandFilter::Handle(User* user, const Params& parameters)
{
if (parameters.size() == 1)
{
return MOD_RES_PASSTHRU;
}
-ModResult ModuleFilter::OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line)
+ModResult ModuleFilter::OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line)
{
if (validated)
{
syntax = "<modulename> [servermask]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
std::string servername = parameters.size() > 1 ? parameters[1] : "*";
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
syntax = "<modulename> [servermask]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (!ServerInstance->Config->ConfValue("security")->getBool("allowcoreunload") &&
InspIRCd::Match(parameters[0], "core_*.so", ascii_case_insensitive_map))
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o'; syntax = "<modulename> [servermask]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
std::string servername = parameters.size() > 1 ? parameters[1] : "*";
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o'; syntax = "<any-text>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
ServerInstance->SNO->WriteGlobalSno('g', "From " + user->nick + ": " + parameters[0]);
return CMD_SUCCESS;
syntax = "<any-text>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
const std::string& parameter = (!parameters.empty() ? parameters[0] : startkey);
redirect_new_users = false;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
int n_done = 0;
reason = (parameters.size() < 4) ? "Please use this server/port instead" : parameters[3];
Penalty = 5;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
Channel* c = ServerInstance->FindChan(parameters[0]);
if (!c)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_BCAST;
}
if (!oper_command)
return;
- std::vector<std::string> params;
+ CommandBase::Params params;
params.push_back(opername);
params.push_back(password);
- oper_command->Handle(params, user);
+ oper_command->Handle(user, params);
}
void Fallback()
attribute = tag->getString("attribute");
}
- ModResult OnPreCommand(std::string& command, std::vector<std::string>& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
if (validated && command == "OPER" && parameters.size() >= 2)
{
flags_needed = 'o';
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (!locked.empty())
{
flags_needed = 'o';
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (locked.empty())
{
url = ServerInstance->Config->ConfValue("security")->getString("maphide");
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
if (validated && !user->IsOper() && !url.empty() && (command == "MAP" || command == "LINKS"))
{
flags_needed = 'o';
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* src) CXX11_OVERRIDE
+ CmdResult Handle(User* src, const Params& parameters) CXX11_OVERRIDE
{
std::string msg = "*** From " + src->nick + ": " + parameters[1];
int mlen = parameters[0].length();
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_BCAST;
}
syntax = "[C|L|S|+ <nick1>[,<nick2>]|- <nick1>[,<nick2>]";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
char subcmd = toupper(parameters[0][0]);
if (subcmd == '+')
syntax = "<user|channel> {[+-]<mode> [<value>]}*";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* src) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* src, const Params& parameters) CXX11_OVERRIDE
{
Channel* const chan = ServerInstance->FindChan(parameters[0]);
if (!chan)
tokens["NAMESX"];
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
/* We don't actually create a proper command handler class for PROTOCTL,
* because other modules might want to have PROTOCTL hooks too.
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE1(TR_NICK);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
active = false;
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
// Make sure the channel name is allowable.
if (!ServerInstance->IsChannel(parameters[0]))
tosnomask = ServerInstance->Config->ConfValue("operlog")->getBool("tosnomask", false);
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
/* If the command doesnt appear to be valid, we dont want to mess with it. */
if (!validated)
std::string buf;
irc::spacesepstream ss(smodes);
- std::vector<std::string> modes;
+ CommandBase::Params modes;
modes.push_back(u->nick);
// split into modes and mode params
flags_needed = 'o'; syntax = "[<servername>]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if ((parameters.empty()) || (parameters[0] == ServerInstance->Config->ServerName))
ShowOperMOTD(user);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
if ((!parameters.empty()) && (parameters[0].find('.') != std::string::npos))
return ROUTE_OPT_UCAST(parameters[0]);
Penalty = 5;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (!parameters[0].compare(0, 5, "hmac-", 5))
{
{
}
- CmdResult HandleRMB(const std::vector<std::string>& parameters, User *user, bool fpart)
+ CmdResult HandleRMB(User* user, const CommandBase::Params& parameters, bool fpart)
{
User* target;
Channel* channel;
{
/* We'll let everyone remove their level and below, eg:
* ops can remove ops, halfops, voices, and those with no mode (no moders actually are set to 1)
- * a ulined target will get a higher level than it's possible for a /remover to get..so they're safe.
+ a ulined target will get a higher level than it's possible for a /remover to get..so they're safe.
* Nobody may remove people with >= protectedrank rank.
*/
unsigned int ulevel = channel->GetPrefixValue(user);
{
// Send an ENCAP REMOVE with parameters being in the old <user> <chan> order which is
// compatible with both 2.0 and 3.0. This also turns FPART into REMOVE.
- std::vector<std::string> p;
+ CommandBase::Params p;
p.push_back(target->uuid);
p.push_back(channel->name);
if (parameters.size() > 2)
TRANSLATE3(TR_NICK, TR_TEXT, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
- return HandleRMB(parameters, user, false);
+ return HandleRMB(user, parameters, false);
}
};
TRANSLATE3(TR_TEXT, TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
- return HandleRMB(parameters, user, true);
+ return HandleRMB(user, parameters, true);
}
};
flags_needed = 'o'; this->syntax = "<regex> [<rline-duration>] :<reason>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters.size() >= 3)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
return ROUTE_LOCALONLY; // spanningtree will send ADDLINE
syntax = "<channel> <mode> [pattern]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
ModeHandler* mh;
Channel* chan = ServerInstance->FindChan(parameters[0]);
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
const unsigned int channelindex = (parameters.size() > 1) ? 1 : 0;
if (CommandParser::LoopCall(user, this, parameters, channelindex))
}
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE3(TR_TEXT, TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[1]);
Channel* channel = ServerInstance->FindChan(parameters[0]);
return CMD_FAILURE;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[1]);
}
active = false;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters[0].c_str()[0] != '#')
{
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE3(TR_NICK, TR_TEXT, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (CommandParser::LoopCall(user, this, parameters, 1))
return CMD_FAILURE;
return CMD_FAILURE;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
if ((dest) && (dest->registered == REG_ALL))
}
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
static Events::ModuleEventProvider* saslevprov;
-static void SendSASL(LocalUser* user, const std::string& agent, char mode, const parameterlist& parameters)
+static void SendSASL(LocalUser* user, const std::string& agent, char mode, const std::vector<std::string>& parameters)
{
- parameterlist params(parameters.size() + 3);
+ CommandBase::Params params(parameters.size() + 3);
params.push_back(user->uuid);
params.push_back(agent);
params.push_back(ConvToStr(mode));
void SendHostIP()
{
- parameterlist params;
+ std::vector<std::string> params;
params.push_back(user->GetRealHost());
params.push_back(user->GetIPString());
params.push_back(SSLIOHook::IsSSL(&user->eh) ? "S" : "P");
{
SendHostIP();
- parameterlist params;
+ std::vector<std::string> params;
params.push_back(method);
const std::string fp = SSLClientCert::GetFingerprint(&user->eh);
}
/* checks for and deals with a state change. */
- SaslState ProcessInboundMessage(const std::vector<std::string> &msg)
+ SaslState ProcessInboundMessage(const CommandBase::Params& msg)
{
switch (this->state)
{
allow_empty_last_param = false;
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
{
if (!cap.get(user))
this->flags_needed = FLAG_SERVERONLY; // should not be called by users
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* target = ServerInstance->FindUUID(parameters[1]);
if (!target)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o'; syntax = "<target> <topic>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
/*
* Handles a SATOPIC request. Notifies all +s users.
* OnPreCommand()
* Intercept the LIST command.
*/
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
/* If the command doesnt appear to be valid, we dont want to mess with it. */
if (!validated)
flags_needed = 'o'; syntax = "<new-hostname>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters[0].length() > ServerInstance->Config->Limits.MaxHost)
{
flags_needed = 'o'; syntax = "<new-ident>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters[0].size() > ServerInstance->Config->Limits.IdentMax)
{
flags_needed = 'o'; syntax = "<duration>";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
int idle = InspIRCd::Duration(parameters[0]);
if (idle < 1)
syntax = "<newname>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters[0].size() > ServerInstance->Config->Limits.MaxGecos)
{
{
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (method == SF_NUMERIC)
{
") did a /whois on you");
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
if (!dest)
}
else
{
- std::vector<std::string> params;
+ CommandBase::Params params;
params.push_back(dest->uuid);
params.push_back(source->uuid);
ServerInstance->PI->SendEncapsulatedData(dest->server->GetName(), cmd.name, params);
flags_needed = 'o'; this->syntax = "<nick!user@hostmask> [<shun-duration>] :<reason>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
/* syntax: SHUN nick!user@host time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (IS_LOCAL(user))
return ROUTE_LOCALONLY; // spanningtree will send ADDLINE
affectopers = tag->getBool("affectopers", false);
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string>& parameters, LocalUser* user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
if (validated)
return MOD_RES_PASSTHRU;
TRANSLATE3(TR_NICK, TR_TEXT, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
/*
* XXX: thought occurs to me
if (IS_LOCAL(u))
{
- ServerInstance->Parser.CallHandler("SILENCE", std::vector<std::string>(parameters.begin() + 1, parameters.end()), u);
+ CommandBase::Params params(parameters.begin() + 1, parameters.end());
+ ServerInstance->Parser.CallHandler("SILENCE", params, u);
}
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
syntax = "{[+|-]<mask> <p|c|i|n|t|a|x>}";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters.empty())
{
#include "utils.h"
#include "commands.h"
-CmdResult CommandAddLine::Handle(User* usr, std::vector<std::string>& params)
+CmdResult CommandAddLine::Handle(User* usr, Params& params)
{
XLineFactory* xlf = ServerInstance->XLines->GetFactory(params[0]);
const std::string& setter = usr->nick;
#include "utils.h"
#include "commands.h"
-CmdResult CommandAway::HandleRemote(::RemoteUser* u, std::vector<std::string>& params)
+CmdResult CommandAway::HandleRemote(::RemoteUser* u, Params& params)
{
if (!params.empty())
{
}
}
-bool TreeSocket::Capab(const parameterlist ¶ms)
+bool TreeSocket::Capab(const CommandBase::Params& params)
{
if (params.size() < 1)
{
{
public:
CommandRConnect(Module* Creator);
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandRSQuit : public Command
{
public:
CommandRSQuit(Module* Creator);
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandMap : public Command
{
public:
CommandMap(Module* Creator);
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandSVSJoin : public ServerCommand
{
public:
CommandSVSJoin(Module* Creator) : ServerCommand(Creator, "SVSJOIN", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandSVSPart : public ServerCommand
{
public:
CommandSVSPart(Module* Creator) : ServerCommand(Creator, "SVSPART", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandSVSNick : public ServerCommand
{
public:
CommandSVSNick(Module* Creator) : ServerCommand(Creator, "SVSNICK", 3) { }
- CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandMetadata : public ServerCommand
{
public:
CommandMetadata(Module* Creator) : ServerCommand(Creator, "METADATA", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
{
public:
CommandUID(Module* Creator) : ServerOnlyServerCommand<CommandUID>(Creator, "UID", 10) { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& params);
+ CmdResult HandleServer(TreeServer* server, CommandBase::Params& params);
class Builder : public CmdBuilder
{
{
public:
CommandOpertype(Module* Creator) : UserOnlyServerCommand<CommandOpertype>(Creator, "OPERTYPE", 1) { }
- CmdResult HandleRemote(RemoteUser* user, std::vector<std::string>& params);
+ CmdResult HandleRemote(RemoteUser* user, Params& params);
class Builder : public CmdBuilder
{
void ProcessModeUUIDPair(const std::string& item, TreeServer* sourceserver, Channel* chan, Modes::ChangeList* modechangelist, FwdFJoinBuilder& fwdfjoin);
public:
CommandFJoin(Module* Creator) : ServerCommand(Creator, "FJOIN", 3) { }
- CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
+ CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
class Builder : public CmdBuilder
{
{
public:
CommandFMode(Module* Creator) : ServerCommand(Creator, "FMODE", 3) { }
- CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
};
class CommandFTopic : public ServerCommand
{
public:
CommandFTopic(Module* Creator) : ServerCommand(Creator, "FTOPIC", 4, 5) { }
- CmdResult Handle(User* user, std::vector<std::string>& params) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
{
public:
CommandFHost(Module* Creator) : UserOnlyServerCommand<CommandFHost>(Creator, "FHOST", 1) { }
- CmdResult HandleRemote(RemoteUser* user, std::vector<std::string>& params);
+ CmdResult HandleRemote(RemoteUser* user, Params& params);
};
class CommandFIdent : public UserOnlyServerCommand<CommandFIdent>
{
public:
CommandFIdent(Module* Creator) : UserOnlyServerCommand<CommandFIdent>(Creator, "FIDENT", 1) { }
- CmdResult HandleRemote(RemoteUser* user, std::vector<std::string>& params);
+ CmdResult HandleRemote(RemoteUser* user, Params& params);
};
class CommandFName : public UserOnlyServerCommand<CommandFName>
{
public:
CommandFName(Module* Creator) : UserOnlyServerCommand<CommandFName>(Creator, "FNAME", 1) { }
- CmdResult HandleRemote(RemoteUser* user, std::vector<std::string>& params);
+ CmdResult HandleRemote(RemoteUser* user, Params& params);
};
class CommandIJoin : public UserOnlyServerCommand<CommandIJoin>
{
public:
CommandIJoin(Module* Creator) : UserOnlyServerCommand<CommandIJoin>(Creator, "IJOIN", 2) { }
- CmdResult HandleRemote(RemoteUser* user, std::vector<std::string>& params);
+ CmdResult HandleRemote(RemoteUser* user, Params& params);
};
class CommandResync : public ServerOnlyServerCommand<CommandResync>
{
public:
CommandResync(Module* Creator) : ServerOnlyServerCommand<CommandResync>(Creator, "RESYNC", 1) { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
+ CmdResult HandleServer(TreeServer* server, Params& parameters);
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
};
class SpanningTree::CommandAway : public UserOnlyServerCommand<SpanningTree::CommandAway>
{
public:
CommandAway(Module* Creator) : UserOnlyServerCommand<SpanningTree::CommandAway>(Creator, "AWAY", 0, 2) { }
- CmdResult HandleRemote(::RemoteUser* user, std::vector<std::string>& parameters);
+ CmdResult HandleRemote(::RemoteUser* user, Params& parameters);
class Builder : public CmdBuilder
{
{
public:
CommandAddLine(Module* Creator) : ServerCommand(Creator, "ADDLINE", 6, 6) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
{
public:
CommandDelLine(Module* Creator) : ServerCommand(Creator, "DELLINE", 2, 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
};
class CommandEncap : public ServerCommand
{
public:
CommandEncap(Module* Creator) : ServerCommand(Creator, "ENCAP", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
};
class CommandIdle : public UserOnlyServerCommand<CommandIdle>
{
public:
CommandIdle(Module* Creator) : UserOnlyServerCommand<CommandIdle>(Creator, "IDLE", 1) { }
- CmdResult HandleRemote(RemoteUser* user, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
+ CmdResult HandleRemote(RemoteUser* user, Params& parameters);
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
};
class SpanningTree::CommandNick : public UserOnlyServerCommand<SpanningTree::CommandNick>
{
public:
CommandNick(Module* Creator) : UserOnlyServerCommand<SpanningTree::CommandNick>(Creator, "NICK", 2) { }
- CmdResult HandleRemote(::RemoteUser* user, std::vector<std::string>& parameters);
+ CmdResult HandleRemote(::RemoteUser* user, Params& parameters);
};
class SpanningTree::CommandPing : public ServerCommand
{
public:
CommandPing(Module* Creator) : ServerCommand(Creator, "PING", 1) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
+ CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
};
class SpanningTree::CommandPong : public ServerOnlyServerCommand<SpanningTree::CommandPong>
{
public:
CommandPong(Module* Creator) : ServerOnlyServerCommand<SpanningTree::CommandPong>(Creator, "PONG", 1) { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
+ CmdResult HandleServer(TreeServer* server, Params& parameters);
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
};
class CommandSave : public ServerCommand
static const time_t SavedTimestamp = 100;
CommandSave(Module* Creator) : ServerCommand(Creator, "SAVE", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
};
class SpanningTree::CommandServer : public ServerOnlyServerCommand<SpanningTree::CommandServer>
{
- static void HandleExtra(TreeServer* newserver, const std::vector<std::string>& params);
+ static void HandleExtra(TreeServer* newserver, Params& params);
public:
CommandServer(Module* Creator) : ServerOnlyServerCommand<SpanningTree::CommandServer>(Creator, "SERVER", 3) { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
+ CmdResult HandleServer(TreeServer* server, Params& parameters);
class Builder : public CmdBuilder
{
{
public:
CommandSQuit(Module* Creator) : ServerOnlyServerCommand<CommandSQuit>(Creator, "SQUIT", 2) { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
+ CmdResult HandleServer(TreeServer* server, Params& parameters);
};
class CommandSNONotice : public ServerCommand
{
public:
CommandSNONotice(Module* Creator) : ServerCommand(Creator, "SNONOTICE", 2) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
};
class CommandEndBurst : public ServerOnlyServerCommand<CommandEndBurst>
{
public:
CommandEndBurst(Module* Creator) : ServerOnlyServerCommand<CommandEndBurst>(Creator, "ENDBURST") { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
+ CmdResult HandleServer(TreeServer* server, Params& parameters);
};
class CommandSInfo : public ServerOnlyServerCommand<CommandSInfo>
{
public:
CommandSInfo(Module* Creator) : ServerOnlyServerCommand<CommandSInfo>(Creator, "SINFO", 2) { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
+ CmdResult HandleServer(TreeServer* server, Params& parameters);
class Builder : public CmdBuilder
{
{
public:
CommandNum(Module* Creator) : ServerOnlyServerCommand<CommandNum>(Creator, "NUM", 3) { }
- CmdResult HandleServer(TreeServer* server, std::vector<std::string>& parameters);
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ CmdResult HandleServer(TreeServer* server, Params& parameters);
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
class Builder : public CmdBuilder
{
namespace
{
- bool InsertCurrentChannelTS(std::vector<std::string>& params, unsigned int chanindex = 0, unsigned int pos = 1)
+ bool InsertCurrentChannelTS(CommandBase::Params& params, unsigned int chanindex = 0, unsigned int pos = 1)
{
Channel* chan = ServerInstance->FindChan(params[chanindex]);
if (!chan)
}
}
-bool TreeSocket::PreProcessOldProtocolMessage(User*& who, std::string& cmd, std::vector<std::string>& params)
+bool TreeSocket::PreProcessOldProtocolMessage(User*& who, std::string& cmd, CommandBase::Params& params)
{
if ((cmd == "METADATA") && (params.size() >= 3) && (params[0][0] == '#'))
{
if ((params.size() != 1) && (params.size() != 3))
return false;
- parameterlist p;
+ CommandBase::Params p;
p.push_back(cmd.substr(0, 1));
p.push_back(params[0]);
#include "commands.h"
-CmdResult CommandDelLine::Handle(User* user, std::vector<std::string>& params)
+CmdResult CommandDelLine::Handle(User* user, Params& params)
{
const std::string& setter = user->nick;
#include "main.h"
/** ENCAP */
-CmdResult CommandEncap::Handle(User* user, std::vector<std::string>& params)
+CmdResult CommandEncap::Handle(User* user, Params& params)
{
if (ServerInstance->Config->GetSID() == params[0] || InspIRCd::Match(ServerInstance->Config->ServerName, params[0]))
{
- parameterlist plist(params.begin() + 2, params.end());
+ CommandBase::Params plist(params.begin() + 2, params.end());
// XXX: Workaround for SVS* commands provided by spanningtree not being registered in the core
if ((params[1] == "SVSNICK") || (params[1] == "SVSJOIN") || (params[1] == "SVSPART"))
return CMD_SUCCESS;
}
-RouteDescriptor CommandEncap::GetRouting(User* user, const std::vector<std::string>& params)
+RouteDescriptor CommandEncap::GetRouting(User* user, const Params& params)
{
if (params[0].find_first_of("*?") != std::string::npos)
return ROUTE_BROADCAST;
};
/** FJOIN, almost identical to TS6 SJOIN, except for nicklist handling. */
-CmdResult CommandFJoin::Handle(User* srcuser, std::vector<std::string>& params)
+CmdResult CommandFJoin::Handle(User* srcuser, Params& params)
{
/* 1.1+ FJOIN works as follows:
*
#include "commands.h"
/** FMODE command - channel mode change with timestamp checks */
-CmdResult CommandFMode::Handle(User* who, std::vector<std::string>& params)
+CmdResult CommandFMode::Handle(User* who, Params& params)
{
time_t TS = ServerCommand::ExtractTS(params[1]);
#include "commands.h"
/** FTOPIC command */
-CmdResult CommandFTopic::Handle(User* user, std::vector<std::string>& params)
+CmdResult CommandFTopic::Handle(User* user, Params& params)
{
Channel* c = ServerInstance->FindChan(params[0]);
if (!c)
#include "utils.h"
#include "commands.h"
-CmdResult CommandIdle::HandleRemote(RemoteUser* issuer, std::vector<std::string>& params)
+CmdResult CommandIdle::HandleRemote(RemoteUser* issuer, Params& params)
{
/**
* There are two forms of IDLE: request and reply. Requests have one parameter,
#include "treeserver.h"
#include "treesocket.h"
-CmdResult CommandIJoin::HandleRemote(RemoteUser* user, std::vector<std::string>& params)
+CmdResult CommandIJoin::HandleRemote(RemoteUser* user, Params& params)
{
Channel* chan = ServerInstance->FindChan(params[0]);
if (!chan)
return CMD_SUCCESS;
}
-CmdResult CommandResync::HandleServer(TreeServer* server, std::vector<std::string>& params)
+CmdResult CommandResync::HandleServer(TreeServer* server, CommandBase::Params& params)
{
ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Resyncing " + params[0]);
Channel* chan = ServerInstance->FindChan(params[0]);
InspIRCd::Format("%d %s", (((Utils->FlatLinks) && (!user->IsOper())) ? 0 : hops), Current->GetDesc().c_str()));
}
-void ModuleSpanningTree::HandleLinks(const std::vector<std::string>& parameters, User* user)
+void ModuleSpanningTree::HandleLinks(const CommandBase::Params& parameters, User* user)
{
ShowLinks(Utils->TreeRoot,user,0);
user->WriteNumeric(RPL_ENDOFLINKS, '*', "End of /LINKS list.");
}
}
-ModResult ModuleSpanningTree::HandleVersion(const std::vector<std::string>& parameters, User* user)
+ModResult ModuleSpanningTree::HandleVersion(const CommandBase::Params& parameters, User* user)
{
// We've already confirmed that !parameters.empty(), so this is safe
TreeServer* found = Utils->FindServerMask(parameters[0]);
return MOD_RES_DENY;
}
-ModResult ModuleSpanningTree::HandleConnect(const std::vector<std::string>& parameters, User* user)
+ModResult ModuleSpanningTree::HandleConnect(const CommandBase::Params& parameters, User* user)
{
for (std::vector<reference<Link> >::iterator i = Utils->LinkBlocks.begin(); i < Utils->LinkBlocks.end(); i++)
{
/** Handle LINKS command
*/
- void HandleLinks(const std::vector<std::string>& parameters, User* user);
+ void HandleLinks(const CommandBase::Params& parameters, User* user);
/** Handle SQUIT
*/
- ModResult HandleSquit(const std::vector<std::string>& parameters, User* user);
+ ModResult HandleSquit(const CommandBase::Params& parameters, User* user);
/** Handle remote WHOIS
*/
- ModResult HandleRemoteWhois(const std::vector<std::string>& parameters, User* user);
+ ModResult HandleRemoteWhois(const CommandBase::Params& parameters, User* user);
/** Connect a server locally
*/
/** Handle remote VERSON
*/
- ModResult HandleVersion(const std::vector<std::string>& parameters, User* user);
+ ModResult HandleVersion(const CommandBase::Params& parameters, User* user);
/** Handle CONNECT
*/
- ModResult HandleConnect(const std::vector<std::string>& parameters, User* user);
+ ModResult HandleConnect(const CommandBase::Params& parameters, User* user);
/** Display a time as a human readable string
*/
** *** MODULE EVENTS ***
**/
- ModResult OnPreCommand(std::string &command, std::vector<std::string>& parameters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE;
- void OnPostCommand(Command*, const std::vector<std::string>& parameters, LocalUser* user, CmdResult result, const std::string& original_line) CXX11_OVERRIDE;
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE;
+ void OnPostCommand(Command*, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, const std::string& original_line) CXX11_OVERRIDE;
void OnUserConnect(LocalUser* source) CXX11_OVERRIDE;
void OnUserInvite(User* source, User* dest, Channel* channel, time_t timeout, unsigned int notifyrank, CUList& notifyexcepts) CXX11_OVERRIDE;
ModResult OnPreTopicChange(User* user, Channel* chan, const std::string& topic) CXX11_OVERRIDE;
#include "inspircd.h"
#include "commands.h"
-CmdResult CommandMetadata::Handle(User* srcuser, std::vector<std::string>& params)
+CmdResult CommandMetadata::Handle(User* srcuser, Params& params)
{
if (params[0] == "*")
{
#include "commands.h"
#include "treeserver.h"
-CmdResult CommandSNONotice::Handle(User* user, std::vector<std::string>& params)
+CmdResult CommandSNONotice::Handle(User* user, Params& params)
{
ServerInstance->SNO->WriteToSnoMask(params[0][0], "From " + user->nick + ": " + params[1]);
return CMD_SUCCESS;
}
-CmdResult CommandEndBurst::HandleServer(TreeServer* server, std::vector<std::string>& params)
+CmdResult CommandEndBurst::HandleServer(TreeServer* server, Params& params)
{
server->FinishBurst();
return CMD_SUCCESS;
#include "commands.h"
#include "treeserver.h"
-CmdResult CommandNick::HandleRemote(::RemoteUser* user, std::vector<std::string>& params)
+CmdResult CommandNick::HandleRemote(::RemoteUser* user, Params& params)
{
if ((isdigit(params[0][0])) && (params[0] != user->uuid))
throw ProtocolException("Attempted to change nick to an invalid or non-matching UUID");
#include "commands.h"
#include "remoteuser.h"
-CmdResult CommandNum::HandleServer(TreeServer* server, std::vector<std::string>& params)
+CmdResult CommandNum::HandleServer(TreeServer* server, CommandBase::Params& params)
{
User* const target = ServerInstance->FindUUID(params[1]);
if (!target)
return CMD_SUCCESS;
}
-RouteDescriptor CommandNum::GetRouting(User* user, const std::vector<std::string>& params)
+RouteDescriptor CommandNum::GetRouting(User* user, const Params& params)
{
return ROUTE_UNICAST(params[1]);
}
{
TreeServer* const server = (numeric.GetServer() ? (static_cast<TreeServer*>(numeric.GetServer())) : Utils->TreeRoot);
push(server->GetID()).push(target->uuid).push(InspIRCd::Format("%03u", numeric.GetNumeric()));
- const std::vector<std::string>& params = numeric.GetParams();
+ const CommandBase::Params& params = numeric.GetParams();
if (!params.empty())
{
- for (std::vector<std::string>::const_iterator i = params.begin(); i != params.end()-1; ++i)
+ for (CommandBase::Params::const_iterator i = params.begin(); i != params.end()-1; ++i)
push(*i);
push_last(params.back());
}
/** Because the core won't let users or even SERVERS set +o,
* we use the OPERTYPE command to do this.
*/
-CmdResult CommandOpertype::HandleRemote(RemoteUser* u, std::vector<std::string>& params)
+CmdResult CommandOpertype::HandleRemote(RemoteUser* u, CommandBase::Params& params)
{
const std::string& opertype = params[0];
if (!u->IsOper())
return map;
}
-CmdResult CommandMap::Handle(const std::vector<std::string>& parameters, User* user)
+CmdResult CommandMap::Handle(User* user, const Params& parameters)
{
if (parameters.size() > 0)
{
return CMD_SUCCESS;
}
-RouteDescriptor CommandMap::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandMap::GetRouting(User* user, const Params& parameters)
{
if (!parameters.empty())
return ROUTE_UNICAST(parameters[0]);
#include "treeserver.h"
#include "treesocket.h"
-ModResult ModuleSpanningTree::HandleSquit(const std::vector<std::string>& parameters, User* user)
+ModResult ModuleSpanningTree::HandleSquit(const CommandBase::Params& parameters, User* user)
{
TreeServer* s = Utils->FindServerMask(parameters[0]);
if (s)
#include "main.h"
#include "commandbuilder.h"
-ModResult ModuleSpanningTree::HandleRemoteWhois(const std::vector<std::string>& parameters, User* user)
+ModResult ModuleSpanningTree::HandleRemoteWhois(const CommandBase::Params& parameters, User* user)
{
User* remote = ServerInstance->FindNickOnly(parameters[1]);
if (remote && !IS_LOCAL(remote))
#include "commands.h"
#include "utils.h"
-CmdResult CommandPing::Handle(User* user, std::vector<std::string>& params)
+CmdResult CommandPing::Handle(User* user, Params& params)
{
if (params[0] == ServerInstance->Config->GetSID())
{
#include "commands.h"
#include "utils.h"
-CmdResult CommandPong::HandleServer(TreeServer* server, std::vector<std::string>& params)
+CmdResult CommandPong::HandleServer(TreeServer* server, CommandBase::Params& params)
{
if (server->IsBursting())
{
#include "treeserver.h"
#include "commandbuilder.h"
-void ModuleSpanningTree::OnPostCommand(Command* command, const std::vector<std::string>& parameters, LocalUser* user, CmdResult result, const std::string& original_line)
+void ModuleSpanningTree::OnPostCommand(Command* command, const CommandBase::Params& parameters, LocalUser* user, CmdResult result, const std::string& original_line)
{
if (result == CMD_SUCCESS)
Utils->RouteCommand(NULL, command, parameters, user);
}
-void SpanningTreeUtilities::RouteCommand(TreeServer* origin, CommandBase* thiscmd, const parameterlist& parameters, User* user)
+void SpanningTreeUtilities::RouteCommand(TreeServer* origin, CommandBase* thiscmd, const CommandBase::Params& parameters, User* user)
{
const std::string& command = thiscmd->name;
RouteDescriptor routing = thiscmd->GetRouting(user, parameters);
#include "main.h"
-ModResult ModuleSpanningTree::OnPreCommand(std::string &command, std::vector<std::string>& parameters, LocalUser *user, bool validated, const std::string &original_line)
+ModResult ModuleSpanningTree::OnPreCommand(std::string &command, CommandBase::Params& parameters, LocalUser *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)
}
}
-bool SpanningTreeProtocolInterface::SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const parameterlist& params, User* source)
+bool SpanningTreeProtocolInterface::SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const CommandBase::Params& params, User* source)
{
if (!source)
source = ServerInstance->FakeClient;
return true;
}
-void SpanningTreeProtocolInterface::BroadcastEncap(const std::string& cmd, const parameterlist& params, User* source, User* omit)
+void SpanningTreeProtocolInterface::BroadcastEncap(const std::string& cmd, const CommandBase::Params& params, User* source, User* omit)
{
if (!source)
source = ServerInstance->FakeClient;
void SendMetaData(const std::string& key, const std::string& data) CXX11_OVERRIDE;
};
- bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const parameterlist& params, User* source) CXX11_OVERRIDE;
- void BroadcastEncap(const std::string& cmd, const parameterlist& params, User* source, User* omit) CXX11_OVERRIDE;
+ bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const CommandBase::Params& params, User* source) CXX11_OVERRIDE;
+ void BroadcastEncap(const std::string& cmd, const CommandBase::Params& params, User* source, User* omit) CXX11_OVERRIDE;
void SendMetaData(User* user, const std::string& key, const std::string& data) CXX11_OVERRIDE;
void SendMetaData(Channel* chan, const std::string& key, const std::string& data) CXX11_OVERRIDE;
void SendMetaData(const std::string& key, const std::string& data) CXX11_OVERRIDE;
syntax = "<remote-server-mask> <target-server-mask>";
}
-CmdResult CommandRConnect::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandRConnect::Handle(User* user, const Params& parameters)
{
/* First see if the server which is being asked to connect to another server in fact exists */
if (!Utils->FindServerMask(parameters[0]))
{
/* Yes, initiate the given connect */
ServerInstance->SNO->WriteToSnoMask('l',"Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick.c_str(),parameters[0].c_str(),parameters[1].c_str());
- std::vector<std::string> para;
+ CommandBase::Params para;
para.push_back(parameters[1]);
((ModuleSpanningTree*)(Module*)creator)->HandleConnect(para, user);
}
return CMD_SUCCESS;
}
-RouteDescriptor CommandRConnect::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandRConnect::GetRouting(User* user, const Params& parameters)
{
return ROUTE_UNICAST(parameters[0]);
}
syntax = "<target-server-mask> [reason]";
}
-CmdResult CommandRSQuit::Handle (const std::vector<std::string>& parameters, User *user)
+CmdResult CommandRSQuit::Handle(User* user, const Params& parameters)
{
TreeServer *server_target; // Server to squit
return CMD_SUCCESS;
}
-RouteDescriptor CommandRSQuit::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandRSQuit::GetRouting(User* user, const Params& parameters)
{
return ROUTE_UNICAST(parameters[0]);
}
/**
* SAVE command - force nick change to UID on timestamp match
*/
-CmdResult CommandSave::Handle(User* user, std::vector<std::string>& params)
+CmdResult CommandSave::Handle(User* user, Params& params)
{
User* u = ServerInstance->FindUUID(params[0]);
if (!u)
* Some server somewhere in the network introducing another server.
* -- w
*/
-CmdResult CommandServer::HandleServer(TreeServer* ParentOfThis, std::vector<std::string>& params)
+CmdResult CommandServer::HandleServer(TreeServer* ParentOfThis, Params& params)
{
const std::string& servername = params[0];
const std::string& sid = params[1];
return CMD_SUCCESS;
}
-void CommandServer::HandleExtra(TreeServer* newserver, const std::vector<std::string>& params)
+void CommandServer::HandleExtra(TreeServer* newserver, Params& params)
{
- for (std::vector<std::string>::const_iterator i = params.begin() + 2; i != params.end() - 1; ++i)
+ for (CommandBase::Params::const_iterator i = params.begin() + 2; i != params.end() - 1; ++i)
{
const std::string& prop = *i;
std::string::size_type p = prop.find('=');
}
}
-Link* TreeSocket::AuthRemote(const parameterlist& params)
+Link* TreeSocket::AuthRemote(const CommandBase::Params& params)
{
if (params.size() < 5)
{
* This is used after the other side of a connection has accepted our credentials.
* They are then introducing themselves to us, BEFORE either of us burst. -- w
*/
-bool TreeSocket::Outbound_Reply_Server(parameterlist ¶ms)
+bool TreeSocket::Outbound_Reply_Server(CommandBase::Params& params)
{
const Link* x = AuthRemote(params);
if (x)
* Someone else is attempting to connect to us if this is called. Validate their credentials etc.
* -- w
*/
-bool TreeSocket::Inbound_Server(parameterlist ¶ms)
+bool TreeSocket::Inbound_Server(CommandBase::Params& params)
{
const Link* x = AuthRemote(params);
if (x)
st->CmdManager.AddCommand(this);
}
-RouteDescriptor ServerCommand::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor ServerCommand::GetRouting(User* user, const Params& parameters)
{
// Broadcast server-to-server commands unless overridden
return ROUTE_BROADCAST;
*/
void RegisterService() CXX11_OVERRIDE;
- virtual CmdResult Handle(User* user, std::vector<std::string>& parameters) = 0;
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE;
+ virtual CmdResult Handle(User* user, Params& parameters) = 0;
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
/**
* Extract the TS from a string.
UserOnlyServerCommand(Module* Creator, const std::string& Name, unsigned int MinPara = 0, unsigned int MaxPara = 0)
: ServerCommand(Creator, Name, MinPara, MaxPara) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE
+ CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE
{
RemoteUser* remoteuser = IS_REMOTE(user);
if (!remoteuser)
ServerOnlyServerCommand(Module* Creator, const std::string& Name, unsigned int MinPara = 0, unsigned int MaxPara = 0)
: ServerCommand(Creator, Name, MinPara, MaxPara) { }
- CmdResult Handle(User* user, std::vector<std::string>& parameters) CXX11_OVERRIDE
+ CmdResult Handle(User* user, CommandBase::Params& parameters) CXX11_OVERRIDE
{
if (!IS_SERVER(user))
throw ProtocolException("Invalid source");
#include "treeserver.h"
#include "commands.h"
-CmdResult CommandSInfo::HandleServer(TreeServer* server, std::vector<std::string>& params)
+CmdResult CommandSInfo::HandleServer(TreeServer* server, CommandBase::Params& params)
{
const std::string& key = params.front();
const std::string& value = params.back();
#include "commands.h"
-CmdResult CommandSVSJoin::Handle(User* user, std::vector<std::string>& parameters)
+CmdResult CommandSVSJoin::Handle(User* user, Params& parameters)
{
// Check for valid channel name
if (!ServerInstance->IsChannel(parameters[1]))
return CMD_SUCCESS;
}
-RouteDescriptor CommandSVSJoin::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandSVSJoin::GetRouting(User* user, const Params& parameters)
{
return ROUTE_OPT_UCAST(parameters[0]);
}
#include "main.h"
#include "commands.h"
-CmdResult CommandSVSNick::Handle(User* user, std::vector<std::string>& parameters)
+CmdResult CommandSVSNick::Handle(User* user, Params& parameters)
{
User* u = ServerInstance->FindNick(parameters[0]);
return CMD_SUCCESS;
}
-RouteDescriptor CommandSVSNick::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandSVSNick::GetRouting(User* user, const Params& parameters)
{
return ROUTE_OPT_UCAST(parameters[0]);
}
#include "commands.h"
-CmdResult CommandSVSPart::Handle(User* user, std::vector<std::string>& parameters)
+CmdResult CommandSVSPart::Handle(User* user, Params& parameters)
{
User* u = ServerInstance->FindUUID(parameters[0]);
if (!u)
return CMD_SUCCESS;
}
-RouteDescriptor CommandSVSPart::GetRouting(User* user, const std::vector<std::string>& parameters)
+RouteDescriptor CommandSVSPart::GetRouting(User* user, const Params& parameters)
{
return ROUTE_OPT_UCAST(parameters[0]);
}
* @param params Parameters they sent in the SERVER command
* @return Link block for the remote server, or NULL if an error occurred
*/
- Link* AuthRemote(const parameterlist& params);
+ Link* AuthRemote(const CommandBase::Params& params);
/** Write a line on this socket with a new line character appended, skipping all translation for old protocols
* @param line Line to write without a new line character at the end
void ListDifference(const std::string &one, const std::string &two, char sep,
std::string& mleft, std::string& mright);
- bool Capab(const parameterlist ¶ms);
+ bool Capab(const CommandBase::Params& params);
/** Send one or more FJOINs for a channel of users.
* If the length of a single line is more than 480-NICKMAX
void WriteLine(const std::string& line);
/** Handle ERROR command */
- void Error(parameterlist ¶ms);
+ void Error(CommandBase::Params& params);
/** (local) -> SERVER
*/
- bool Outbound_Reply_Server(parameterlist ¶ms);
+ bool Outbound_Reply_Server(CommandBase::Params& params);
/** (local) <- SERVER
*/
- bool Inbound_Server(parameterlist ¶ms);
+ bool Inbound_Server(CommandBase::Params& params);
/** Handle IRC line split
*/
- void Split(const std::string &line, std::string& prefix, std::string& command, parameterlist ¶ms);
+ void Split(const std::string &line, std::string& prefix, std::string& command, CommandBase::Params& params);
/** Process complete line from buffer
*/
void ProcessLine(std::string &line);
- void ProcessConnectedLine(std::string& prefix, std::string& command, parameterlist& params);
+ void ProcessConnectedLine(std::string& prefix, std::string& command, CommandBase::Params& params);
/** Handle socket timeout from connect()
*/
/** Fixes messages coming from old servers so the new command handlers understand them
*/
- bool PreProcessOldProtocolMessage(User*& who, std::string& cmd, std::vector<std::string>& params);
+ bool PreProcessOldProtocolMessage(User*& who, std::string& cmd, CommandBase::Params& params);
};
SetError(errormessage);
}
-CmdResult CommandSQuit::HandleServer(TreeServer* server, std::vector<std::string>& params)
+CmdResult CommandSQuit::HandleServer(TreeServer* server, CommandBase::Params& params)
{
TreeServer* quitting = Utils->FindServer(params[0]);
if (!quitting)
#include "commands.h"
/* Handle ERROR command */
-void TreeSocket::Error(parameterlist ¶ms)
+void TreeSocket::Error(CommandBase::Params& params)
{
std::string msg = params.size() ? params[0] : "";
SetError("received ERROR " + msg);
}
-void TreeSocket::Split(const std::string& line, std::string& prefix, std::string& command, parameterlist& params)
+void TreeSocket::Split(const std::string& line, std::string& prefix, std::string& command, CommandBase::Params& params)
{
irc::tokenstream tokens(line);
{
std::string prefix;
std::string command;
- parameterlist params;
+ CommandBase::Params params;
ServerInstance->Logs->Log(MODNAME, LOG_RAWIO, "S[%d] I %s", this->GetFd(), line.c_str());
return NULL;
}
-void TreeSocket::ProcessConnectedLine(std::string& prefix, std::string& command, parameterlist& params)
+void TreeSocket::ProcessConnectedLine(std::string& prefix, std::string& command, CommandBase::Params& params)
{
User* who = FindSource(prefix, command);
if (!who)
res = scmd->Handle(who, params);
else
{
- res = cmd->Handle(params, who);
+ res = cmd->Handle(who, params);
if (res == CMD_INVALID)
throw ProtocolException("Error in command handler");
}
#include "treeserver.h"
#include "remoteuser.h"
-CmdResult CommandUID::HandleServer(TreeServer* remoteserver, std::vector<std::string>& params)
+CmdResult CommandUID::HandleServer(TreeServer* remoteserver, CommandBase::Params& params)
{
/**
* 0 1 2 3 4 5 6 7 8 9 (n-1)
return CMD_SUCCESS;
}
-CmdResult CommandFHost::HandleRemote(RemoteUser* src, std::vector<std::string>& params)
-{
+CmdResult CommandFHost::HandleRemote(RemoteUser* src, Params& params)
+{
src->ChangeDisplayedHost(params[0]);
return CMD_SUCCESS;
}
-CmdResult CommandFIdent::HandleRemote(RemoteUser* src, std::vector<std::string>& params)
+CmdResult CommandFIdent::HandleRemote(RemoteUser* src, Params& params)
{
src->ChangeIdent(params[0]);
return CMD_SUCCESS;
}
-CmdResult CommandFName::HandleRemote(RemoteUser* src, std::vector<std::string>& params)
+CmdResult CommandFName::HandleRemote(RemoteUser* src, Params& params)
{
src->ChangeName(params[0]);
return CMD_SUCCESS;
*/
~SpanningTreeUtilities();
- void RouteCommand(TreeServer* origin, CommandBase* cmd, const parameterlist& parameters, User* user);
+ void RouteCommand(TreeServer* origin, CommandBase* cmd, const CommandBase::Params& parameters, User* user);
/** Send a message from this server to one other local or remote
*/
if (oper_command)
{
- std::vector<std::string> params;
+ CommandBase::Params params;
params.push_back(username);
params.push_back(password);
return;
// Now handle /OPER.
- oper_command->Handle(params, user);
+ oper_command->Handle(user, params);
}
else
{
}
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
// If we are not in the middle of an existing /OPER and someone is trying to oper-up
if (validated && command == "OPER" && parameters.size() >= 2 && !active)
this->syntax = "<nick>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* target = ServerInstance->FindNickOnly(parameters[0]);
}
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
if ((command == "OPER") && (validated))
{
works_before_reg = true;
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
if (!ssl)
{
flags_needed = 'o'; this->syntax = "<nickname> [<duration> :<reason>]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
/* syntax: svshold nickname time :reason goes here */
/* 'time' is a human-readable timestring, like 2d3h2s. */
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* dest = ServerInstance->FindNick(parameters[0]);
syntax = "<channel> <duration> <banmask>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
Channel* channel = ServerInstance->FindChan(parameters[0]);
if (!channel)
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
flags_needed = 'o'; this->syntax = "<mask>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
unsigned int n_matched = 0;
unsigned int n_match_host = 0;
flags_needed = FLAG_SERVERONLY;
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
if (!user->server->IsULine())
{
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_BROADCAST;
}
tokens["UHNAMES"];
}
- ModResult OnPreCommand(std::string &command, std::vector<std::string> ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE
+ ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
{
/* We don't actually create a proper command handler class for PROTOCTL,
* because other modules might want to have PROTOCTL hooks too.
TRANSLATE2(TR_NICK, TR_TEXT);
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
User* u;
if (IS_LOCAL(user))
return CMD_SUCCESS;
}
- RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+ RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE
{
return ROUTE_OPT_UCAST(parameters[0]);
}
syntax = "<nick> [<nick> ...]";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
std::string retbuf;
int nicks = 0;
syntax = "<username> <password>";
}
- CmdResult Handle(const std::vector<std::string>& parameters, User* user) CXX11_OVERRIDE
+ CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE
{
ConfigTagList tags = ServerInstance->Config->ConfTags("vhost");
for(ConfigIter i = tags.first; i != tags.second; ++i)
syntax = "[<C|L|S|l|+<nick1>|-<nick>>]";
}
- CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user) CXX11_OVERRIDE
+ CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE
{
if (parameters.empty())
{
/* Trigger MOTD and LUSERS output, give modules a chance too */
ModResult MOD_RESULT;
std::string command("LUSERS");
- std::vector<std::string> parameters;
+ CommandBase::Params parameters;
FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, parameters, this, true, command));
if (!MOD_RESULT)
ServerInstance->Parser.CallHandler(command, parameters, this);
namespace
{
- std::string BuildNumeric(const std::string& source, User* targetuser, unsigned int num, const std::vector<std::string>& params)
+ std::string BuildNumeric(const std::string& source, User* targetuser, unsigned int num, const Command::Params& params)
{
const char* const target = (targetuser->registered & REG_NICK ? targetuser->nick.c_str() : "*");
std::string raw = InspIRCd::Format(":%s %03u %s", source.c_str(), num, target);
projects / user / henk / code / inspircd.git / commitdiff