* @param commandname The command to find. This should be in uppercase.
* @param parameters Parameter list
* @param user The user to call the handler on behalf of
+ * @param cmd If non-NULL and the command was executed it is set to the command handler,
+ * otherwise it isn't written to.
* @return This method will return CMD_SUCCESS if the command handler was found and called,
* and the command completeld successfully. It will return CMD_FAILURE if the command handler was found
* and called, but the command did not complete successfully, and it will return CMD_INVALID if the
* 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);
+ CmdResult CallHandler(const std::string& commandname, const std::vector<std::string>& parameters, User* user, Command** cmd = NULL);
/** Get the handler function for a command.
* @param commandname The command required. Always use uppercase for this parameter.
class CoreExport Command : public CommandBase
{
public:
+ /** If true, the command will not be forwarded by the linking module even if it comes via ENCAP.
+ * Can be used to forward commands before their effects.
+ */
+ bool force_manual_route;
+
Command(Module* me, const std::string& cmd, unsigned int minpara = 0, unsigned int maxpara = 0)
: CommandBase(me, cmd, minpara, maxpara)
+ , force_manual_route(false)
{
}
*/
virtual bool SendEncapsulatedData(const std::string& targetmask, const std::string& cmd, const parameterlist& params, User* source = NULL) { return false; }
+ /** Send an ENCAP message to all servers.
+ * See the protocol documentation for the purpose of ENCAP.
+ * @param cmd The ENCAP subcommand
+ * @param params List of string parameters which are dependant on the subcommand
+ * @param source The source of the message (prefix), must be a local user or a user behind 'omit'
+ * 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) { }
+
/** Send metadata for a channel to other linked servers.
* @param chan The channel to send metadata for
* @param key The 'key' of the data, e.g. "swhois" for swhois desc on a user
// calls a handler function for a command
-CmdResult CommandParser::CallHandler(const std::string &commandname, const std::vector<std::string>& parameters, User *user)
+CmdResult CommandParser::CallHandler(const std::string& commandname, const std::vector<std::string>& parameters, User* user, Command** cmd)
{
Commandtable::iterator n = cmdlist.find(commandname);
if (bOkay)
{
+ if (cmd)
+ *cmd = n->second;
return n->second->Handle(parameters,user);
}
}
if (ServerInstance->Config->GetSID() == params[0] || InspIRCd::Match(ServerInstance->Config->ServerName, params[0]))
{
parameterlist plist(params.begin() + 2, params.end());
- ServerInstance->Parser->CallHandler(params[1], plist, user);
+ Command* cmd = NULL;
+ ServerInstance->Parser->CallHandler(params[1], plist, user, &cmd);
// Discard return value, ENCAP shall succeed even if the command does not exist
+
+ if ((cmd) && (cmd->force_manual_route))
+ return CMD_FAILURE;
}
return CMD_SUCCESS;
}
return true;
}
+void SpanningTreeProtocolInterface::BroadcastEncap(const std::string& cmd, const parameterlist& params, User* source, User* omit)
+{
+ if (!source)
+ source = ServerInstance->FakeClient;
+
+ // If omit is non-NULL we pass the route belonging to the user to Forward(),
+ // otherwise we pass NULL, which is equivalent to Broadcast()
+ TreeServer* server = (omit ? TreeServer::Get(omit)->GetRoute() : NULL);
+ CmdBuilder(source, "ENCAP * ").push_raw(cmd).insert(params).Forward(server);
+}
+
void SpanningTreeProtocolInterface::SendMetaData(User* u, const std::string& key, const std::string& data)
{
CommandMetadata::Builder(u, key, data).Broadcast();
};
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;
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;