/*
* InspIRCd -- Internet Relay Chat Daemon
*
+ * Copyright (C) 2014, 2017-2020 Sadie Powell <sadie@witchery.services>
+ * Copyright (C) 2012-2016, 2018 Attila Molnar <attilamolnar@hush.com>
+ * Copyright (C) 2012 Robby <robby@chatbelgie.be>
* Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
- * Copyright (C) 2006-2008 Robin Burchell <robin+git@viroteck.net>
- * Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
- * Copyright (C) 2005-2008 Craig Edwards <craigedwards@brainbox.cc>
- * Copyright (C) 2006-2007 Dennis Friis <peavey@inspircd.org>
+ * Copyright (C) 2007-2009 Robin Burchell <robin+git@viroteck.net>
+ * Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
+ * Copyright (C) 2006-2008, 2010 Craig Edwards <brain@inspircd.org>
*
* This file is part of InspIRCd. InspIRCd is free software: you can
* redistribute it and/or modify it under the terms of the GNU General Public
return false;
/* We dont handle any hash types except for plaintext - Thanks tra26 */
- if (!hashtype.empty() && hashtype != "plaintext")
+ if (!hashtype.empty() && !stdalgo::string::equalsci(hashtype, "plaintext"))
return false;
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;
*
* Only check for duplicates if there is one list (allow them in JOIN).
*/
- insp::flat_set<irc::string> dupes;
+ insp::flat_set<std::string, irc::insensitive_swo> dupes;
bool check_dupes = (extra < 0);
/* Create two sepstreams, if we have only one list, then initialize the second sepstream with
* for every parameter or parameter pair until there are no more
* left to parse.
*/
+ CommandBase::Params splitparams(parameters);
while (items1.GetToken(item) && (!usemax || max++ < ServerInstance->Config->MaxTargets))
{
- if ((!check_dupes) || (dupes.insert(item.c_str()).second))
+ if ((!check_dupes) || (dupes.insert(item).second))
{
- std::vector<std::string> new_parameters(parameters);
- new_parameters[splithere] = item;
+ splitparams[splithere] = item;
if (extra >= 0)
{
// If we have two lists then get the next item from the second list.
// In case it runs out of elements then 'item' will be an empty string.
items2.GetToken(item);
- new_parameters[extra] = item;
+ splitparams[extra] = item;
}
- CmdResult result = handler->Handle(new_parameters, user);
+ CmdResult result = handler->Handle(user, splitparams);
if (localuser)
{
- // Run the OnPostCommand hook with the last parameter (original line) being empty
- // to indicate that the command had more targets in its original form.
+ // Run the OnPostCommand hook with the last parameter being true to indicate
+ // that the event is being called in a loop.
item.clear();
- FOREACH_MOD(OnPostCommand, (handler, new_parameters, localuser, result, item));
+ FOREACH_MOD(OnPostCommand, (handler, splitparams, localuser, result, true));
}
}
}
// 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 (user->IsModeSet(n->second->flags_needed))
{
/* if user has the flags, and now has the permissions, go ahead */
- if (user->HasPermission(commandname))
+ if (user->HasCommandPermission(commandname))
bOkay = true;
}
}
{
if (cmd)
*cmd = n->second;
- return n->second->Handle(parameters,user);
+
+ ClientProtocol::TagMap tags;
+ return n->second->Handle(user, CommandBase::Params(parameters, tags));
}
}
}
return CMD_INVALID;
}
-void CommandParser::ProcessCommand(LocalUser *user, std::string &cmd)
+void CommandParser::ProcessCommand(LocalUser* user, std::string& command, CommandBase::Params& command_p)
{
- std::vector<std::string> command_p;
- irc::tokenstream tokens(cmd);
- std::string command, token;
- tokens.GetToken(command);
-
- /* A client sent a nick prefix on their command (ick)
- * rhapsody and some braindead bouncers do this --
- * the rfc says they shouldnt but also says the ircd should
- * discard it if they do.
- */
- if (command[0] == ':')
- tokens.GetToken(command);
-
- while (tokens.GetToken(token))
- command_p.push_back(token);
-
- std::transform(command.begin(), command.end(), command.begin(), ::toupper);
-
/* find the command, check it exists */
Command* handler = GetHandler(command);
if (!handler)
{
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, false, cmd));
+ FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, false));
if (MOD_RESULT == MOD_RES_DENY)
+ {
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
return;
+ }
/*
* This double lookup is in case a module (abbreviation) wishes to change a command.
if (!handler)
{
if (user->registered == REG_ALL)
- user->WriteNumeric(ERR_UNKNOWNCOMMAND, "%s :Unknown command",command.c_str());
+ user->WriteNumeric(ERR_UNKNOWNCOMMAND, command, "Unknown command");
+
ServerInstance->stats.Unknown++;
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
return;
}
}
*/
// 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);
* truncate to max_params if necessary. -- w00t
*/
ModResult MOD_RESULT;
- FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, false, cmd));
+ FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, false));
if (MOD_RESULT == MOD_RES_DENY)
+ {
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
return;
+ }
/* activity resets the ping pending timer */
- user->nping = ServerInstance->Time() + user->MyClass->GetPingTime();
+ user->nextping = ServerInstance->Time() + user->MyClass->GetPingTime();
if (handler->flags_needed)
{
if (!user->IsModeSet(handler->flags_needed))
{
user->CommandFloodPenalty += failpenalty;
- user->WriteNumeric(ERR_NOPRIVILEGES, ":Permission Denied - You do not have the required operator privileges");
+ user->WriteNumeric(ERR_NOPRIVILEGES, "Permission Denied - You do not have the required operator privileges");
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
return;
}
- if (!user->HasPermission(command))
+ if (!user->HasCommandPermission(command))
{
user->CommandFloodPenalty += failpenalty;
- user->WriteNumeric(ERR_NOPRIVILEGES, ":Permission Denied - Oper type %s does not have access to command %s",
- user->oper->name.c_str(), command.c_str());
+ user->WriteNumeric(ERR_NOPRIVILEGES, InspIRCd::Format("Permission Denied - Oper type %s does not have access to command %s",
+ user->oper->name.c_str(), command.c_str()));
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
return;
}
}
- if ((user->registered == REG_ALL) && (!user->IsOper()) && (handler->IsDisabled()))
- {
- /* command is disabled! */
- user->CommandFloodPenalty += failpenalty;
- if (ServerInstance->Config->DisabledDontExist)
- {
- user->WriteNumeric(ERR_UNKNOWNCOMMAND, "%s :Unknown command", command.c_str());
- }
- else
- {
- user->WriteNumeric(ERR_UNKNOWNCOMMAND, "%s :This command has been disabled.", command.c_str());
- }
-
- ServerInstance->SNO->WriteToSnoMask('a', "%s denied for %s (%s@%s)",
- command.c_str(), user->nick.c_str(), user->ident.c_str(), user->host.c_str());
- return;
- }
-
if ((!command_p.empty()) && (command_p.back().empty()) && (!handler->allow_empty_last_param))
command_p.pop_back();
if (command_p.size() < handler->min_params)
{
user->CommandFloodPenalty += failpenalty;
- user->WriteNumeric(ERR_NEEDMOREPARAMS, "%s :Not enough parameters.", command.c_str());
+ user->WriteNumeric(ERR_NEEDMOREPARAMS, command, "Not enough parameters.");
if ((ServerInstance->Config->SyntaxHints) && (user->registered == REG_ALL) && (handler->syntax.length()))
- user->WriteNumeric(RPL_SYNTAX, ":SYNTAX %s %s", handler->name.c_str(), handler->syntax.c_str());
+ user->WriteNumeric(RPL_SYNTAX, handler->name, handler->syntax);
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
return;
}
- if ((user->registered != REG_ALL) && (!handler->WorksBeforeReg()))
+ if ((user->registered != REG_ALL) && (!handler->works_before_reg))
{
user->CommandFloodPenalty += failpenalty;
- user->WriteNumeric(ERR_NOTREGISTERED, "%s :You have not registered",command.c_str());
+ user->WriteNumeric(ERR_NOTREGISTERED, command, "You have not registered");
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
}
else
{
handler->use_count++;
/* module calls too */
- FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, true, cmd));
+ FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, command_p, user, true));
if (MOD_RESULT == MOD_RES_DENY)
+ {
+ FOREACH_MOD(OnCommandBlocked, (command, command_p, user));
return;
+ }
/*
* 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));
+ FOREACH_MOD(OnPostCommand, (handler, command_p, user, result, false));
}
}
cmdlist.erase(n);
}
-CommandBase::CommandBase(Module* mod, const std::string& cmd, unsigned int minpara, unsigned int maxpara)
- : ServiceProvider(mod, cmd, SERVICE_COMMAND)
- , flags_needed(0)
- , min_params(minpara)
- , max_params(maxpara)
- , use_count(0)
- , disabled(false)
- , works_before_reg(false)
- , allow_empty_last_param(true)
- , Penalty(1)
-{
-}
-
-CommandBase::~CommandBase()
+void CommandParser::ProcessBuffer(LocalUser* user, const std::string& buffer)
{
-}
-
-void CommandBase::EncodeParameter(std::string& parameter, int index)
-{
-}
-
-RouteDescriptor CommandBase::GetRouting(User* user, const std::vector<std::string>& parameters)
-{
- return ROUTE_LOCALONLY;
-}
-
-Command::Command(Module* mod, const std::string& cmd, unsigned int minpara, unsigned int maxpara)
- : CommandBase(mod, cmd, minpara, maxpara)
- , force_manual_route(false)
-{
-}
-
-Command::~Command()
-{
- ServerInstance->Parser.RemoveCommand(this);
-}
-
-void CommandParser::ProcessBuffer(std::string &buffer,LocalUser *user)
-{
- if (buffer.empty())
+ ClientProtocol::ParseOutput parseoutput;
+ if (!user->serializer->Parse(user, buffer, parseoutput))
return;
- ServerInstance->Logs->Log("USERINPUT", LOG_RAWIO, "C[%s] I :%s %s",
- user->uuid.c_str(), user->nick.c_str(), buffer.c_str());
- ProcessCommand(user,buffer);
+ std::string& command = parseoutput.cmd;
+ std::transform(command.begin(), command.end(), command.begin(), ::toupper);
+
+ CommandBase::Params parameters(parseoutput.params, parseoutput.tags);
+ ProcessCommand(user, command, parameters);
}
bool CommandParser::AddCommand(Command *f)
{
}
-std::string CommandParser::TranslateUIDs(const std::vector<TranslateType>& to, const std::vector<std::string>& source, bool prefix_final, CommandBase* custom_translator)
+std::string CommandParser::TranslateUIDs(const std::vector<TranslateType>& to, const CommandBase::Params& source, bool prefix_final, CommandBase* custom_translator)
{
std::vector<TranslateType>::const_iterator types = to.begin();
std::string dest;
}
// If no custom translator was given, fall through
}
- case TR_TEXT:
+ /*@fallthrough@*/
default:
/* Do nothing */
dest.append(item);