cmd_nick* command_nick;
cmd_pass* command_pass;
-/* This function pokes and hacks at a parameter list like the following:
- *
- * PART #winbot,#darkgalaxy :m00!
- *
- * to turn it into a series of individual calls like this:
- *
- * PART #winbot :m00!
- * PART #darkgalaxy :m00!
- *
- * The seperate calls are sent to a callback function provided by the caller
- * (the caller will usually call itself recursively). The callback function
- * must be a command handler. Calling this function on a line with no list causes
- * no action to be taken. You must provide a starting and ending parameter number
- * where the range of the list can be found, useful if you have a terminating
- * parameter as above which is actually not part of the list, or parameters
- * before the actual list as well. This code is used by many functions which
- * can function as "one to list" (see the RFC) */
-
-int CommandParser::LoopCall(command_t* fn, const char** parameters, int pcnt, userrec *u, int start, int end, int joins)
+
+/* LoopCall is used to call a command classes handler repeatedly based on the contents of a comma seperated list.
+ * There are two overriden versions of this method, one of which takes two potential lists and the other takes one.
+ * We need a version which takes two potential lists for JOIN, because a JOIN may contain two lists of items at once,
+ * the channel names and their keys as follows:
+ * JOIN #chan1,#chan2,#chan3 key1,,key3
+ * Therefore, we need to deal with both lists concurrently. The first instance of this method does that by creating
+ * two instances of irc::commasepstream and reading them both together until the first runs out of tokens.
+ * The second version is much simpler and just has the one stream to read, and is used in NAMES, WHOIS, PRIVMSG etc.
+ * Both will only parse until they reach Config->MaxTargets number of targets, to stop abuse via spam.
+ */
+int CommandParser::LoopCall(userrec* user, command_t* CommandObj, const char** parameters, int pcnt, unsigned int splithere, unsigned int extra)
{
- /* Copy of the parameter list, because like strltok, we make a bit of
- * a mess of the parameter string we're given, and we want to keep this
- * private.
- */
- char paramlist[MAXBUF];
- /* Temporary variable used to hold one split parameter
- */
- char *param;
- /* Parameter list, we can have up to 32 of these
- */
- const char *pars[32];
- /* Seperated items, e.g. holds the #one and #two from "#one,#two"
- */
- const char *sep_items[32];
- /* Seperated keys, holds the 'two' and 'three' of "two,three"
- */
- const char *sep_keys[32];
- /* Misc. counters, the total values hold the total number of
- * seperated items in sep_items (total) and the total number of
- * seperated items in sep_keys (total2)
- */
- int j = 0, q = 0, total = 0, total2 = 0;
- /* A temporary copy of the comma seperated key list (see the description
- * of the paramlist variable)
- */
- char keylist[MAXBUF];
- /* Exactly what it says. Its nothing. We point invalid parameters at this.
+ /* First check if we have more than one item in the list, if we don't we return zero here and the handler
+ * which called us just carries on as it was.
*/
- char nothing = 0;
-
- /* First, initialize our arrays */
- for (int i = 0; i < 32; i++)
- sep_items[i] = sep_keys[i] = NULL;
+ if (!strchr(parameters[splithere],','))
+ return 0;
- /* Now find all parameters that are NULL, maybe above pcnt,
- * and for safety, point them at 'nothing'
+ /* Create two lists, one for channel names, one for keys
*/
- for (int i = 0; i < 10; i++)
- {
- if (!parameters[i])
- {
- parameters[i] = ¬hing;
- }
- }
- /* Check if we're doing JOIN handling. JOIN has two lists in
- * it, potentially, if we have keys, so this is a special-case
- * to handle the keys if they are provided.
+ irc::commasepstream items1(parameters[splithere]);
+ irc::commasepstream items2(parameters[extra]);
+ std::string item = "";
+ unsigned int max = 0;
+
+ /* Attempt to iterate these lists and call the command objech
+ * which called us, for every parameter pair until there are
+ * no more left to parse.
*/
- if (joins)
+ while (((item = items1.GetToken()) != "") && (max++ < Config->MaxTargets))
{
- if (pcnt > 1) /* we have a key to copy */
- {
- strlcpy(keylist,parameters[1],MAXBUF);
- }
+ std::string extrastuff = items2.GetToken();
+ parameters[splithere] = item.c_str();
+ parameters[extra] = extrastuff.c_str();
+ CommandObj->Handle(parameters,pcnt,user);
}
+ return 1;
+}
- /* There's nothing to split! We don't do anything
+int CommandParser::LoopCall(userrec* user, command_t* CommandObj, const char** parameters, int pcnt, unsigned int splithere)
+{
+ /* First check if we have more than one item in the list, if we don't we return zero here and the handler
+ * which called us just carries on as it was.
*/
- if (!parameters[start] || (!strchr(parameters[start],',')))
- {
+ if (!strchr(parameters[splithere],','))
return 0;
- }
- /* This function can handle multiple comma seperated
- * lists as one, which is a feature no actual commands
- * have yet -- this is futureproofing in case we encounter
- * a command that does.
- */
- *paramlist = 0;
-
- for (int i = start; i <= end; i++)
- {
- if (parameters[i])
- {
- strlcat(paramlist,parameters[i],MAXBUF);
- }
- }
-
- /* Now we split off paramlist into seperate parameters using
- * pointer voodoo, this parameter list goes into sep_items
- */
- j = 0;
- param = paramlist;
-
- for (char* i = paramlist; *i; i++)
- {
- /* Found an item */
- if (*i == ',')
- {
- *i = '\0';
- sep_items[j++] = param;
- /* Iterate along to next item, if there is one */
- param = i+1;
- if ((unsigned int)j > Config->MaxTargets)
- {
- /* BZZT! Too many items */
- WriteServ(u->fd,"407 %s %s :Too many targets in list, message not delivered.",u->nick,sep_items[j-1]);
- return 1;
- }
- }
- }
- sep_items[j++] = param;
- total = j;
+ /* Only one commasepstream here */
+ irc::commasepstream items1(parameters[splithere]);
+ std::string item = "";
+ unsigned int max = 0;
- /* We add this extra comma here just to ensure we get all the keys
- * in the event the user gave a malformed key string (yes, you guessed
- * it, this is a mirc-ism)
+ /* Parse the commasepstream until there are no tokens remaining.
+ * Each token we parse out, call the command handler that called us
+ * with it
*/
- if ((joins) && (*keylist) && (total>0)) // more than one channel and is joining
+ while (((item = items1.GetToken()) != "") && (max++ < Config->MaxTargets))
{
- charlcat(keylist,',',MAXBUF);
- }
-
- /* If we're doing JOIN handling (e.g. we've had to kludge for two
- * lists being handled at once, real smart by the way JRO </sarcasm>)
- * and we also have keys, we must seperate out this key list into
- * our char** list sep_keys for later use.
- */
- if ((joins) && (*keylist))
- {
- /* There is more than one key */
- if (strchr(keylist,','))
- {
- j = 0;
- param = keylist;
- for (char* i = keylist; *i; i++)
- {
- if (*i == ',')
- {
- *i = '\0';
- sep_keys[j++] = param;
- param = i+1;
- }
- }
-
- sep_keys[j++] = param;
- total2 = j;
- }
+ parameters[splithere] = item.c_str();
+ CommandObj->Handle(parameters,pcnt,user);
}
-
- /* Now the easier bit. We call the command class's Handle function
- * X times, where x is the number of parameters we've 'collated'.
+ /* By returning 1 we tell our caller that nothing is to be done,
+ * as all the previous calls handled the data. This makes the parent
+ * return without doing any processing.
*/
- for (j = 0; j < total; j++)
- {
- if (sep_items[j])
- {
- pars[0] = sep_items[j];
- }
-
- for (q = end; q < pcnt-1; q++)
- {
- if (parameters[q+1])
- {
- pars[q-end+1] = parameters[q+1];
- }
- }
-
- if ((joins) && (parameters[1]))
- {
- if (pcnt > 1)
- {
- pars[1] = sep_keys[j];
- }
- else
- {
- pars[1] = NULL;
- }
- }
-
- /* repeatedly call the function with the hacked parameter list */
- if ((joins) && (pcnt > 1))
- {
- if (pars[1])
- {
- /* pars[1] already set up and containing key from sep_keys[j] */
- fn->Handle(pars,2,u);
- }
- else
- {
- pars[1] = parameters[1];
- fn->Handle(pars,2,u);
- }
- }
- else
- {
- fn->Handle(pars,pcnt-(end-start),u);
- }
- }
-
return 1;
}
int items = 0;
std::string para[127];
irc::tokenstream tokens(cmd);
- std::string xcommand = tokens.GetToken();
+ std::string command = tokens.GetToken();
while (((para[items] = tokens.GetToken()) != "") && (items < 127))
command_p[items] = para[items++].c_str();
+
+ for (std::string::iterator makeupper = command.begin(); makeupper != command.end(); makeupper++)
+ *makeupper = toupper(*makeupper);
int MOD_RESULT = 0;
- FOREACH_RESULT(I_OnPreCommand,OnPreCommand(xcommand,command_p,items,user,false));
+ FOREACH_RESULT(I_OnPreCommand,OnPreCommand(command,command_p,items,user,false));
if (MOD_RESULT == 1) {
return;
}
- nspace::hash_map<std::string,command_t*>::iterator cm = cmdlist.find(xcommand);
+ nspace::hash_map<std::string,command_t*>::iterator cm = cmdlist.find(command);
if (cm != cmdlist.end())
{
{
/* activity resets the ping pending timer */
user->nping = TIME + user->pingmax;
- if (items < cm->second->min_params)
- {
- log(DEBUG,"not enough parameters: %s %s",user->nick,xcommand.c_str());
- WriteServ(user->fd,"461 %s %s :Not enough parameters",user->nick,xcommand.c_str());
- return;
- }
if (cm->second->flags_needed)
{
if (!user->IsModeSet(cm->second->flags_needed))
{
- log(DEBUG,"permission denied: %s %s",user->nick,xcommand.c_str());
WriteServ(user->fd,"481 %s :Permission Denied- You do not have the required operator privilages",user->nick);
return;
}
- }
- if ((cm->second->flags_needed) && (!user->HasPermission(xcommand)))
- {
- log(DEBUG,"permission denied: %s %s",user->nick,xcommand.c_str());
- WriteServ(user->fd,"481 %s :Permission Denied- Oper type %s does not have access to command %s",user->nick,user->oper,xcommand.c_str());
- return;
- }
- /* if the command isnt USER, PASS, or NICK, and nick is empty,
- * deny command! */
- if ((cm->second != command_user) && (cm->second != command_nick) && (cm->second != command_pass))
- {
- if ((!isnick(user->nick)) || (user->registered != 7))
+ if (!user->HasPermission(command))
{
- log(DEBUG,"not registered: %s %s",user->nick,xcommand.c_str());
- WriteServ(user->fd,"451 %s :You have not registered",xcommand.c_str());
+ WriteServ(user->fd,"481 %s :Permission Denied- Oper type %s does not have access to command %s",user->nick,user->oper,command.c_str());
return;
}
}
- if ((user->registered == 7) && (!*user->oper) && (*Config->DisabledCommands))
+ if ((user->registered == REG_ALL) && (!*user->oper) && (cm->second->IsDisabled()))
{
- /* XXX: We should have a disabled setting in the command object, and on rehash set the disabled flag
- * in the ones which are disabled, rather than this craq
- */
- std::stringstream dcmds(Config->DisabledCommands);
- std::string thiscmd;
- while (dcmds >> thiscmd)
- {
- if (!strcasecmp(thiscmd.c_str(),xcommand.c_str()))
- {
- // command is disabled!
- WriteServ(user->fd,"421 %s %s :This command has been disabled.",user->nick,xcommand.c_str());
- return;
- }
- }
+ /* command is disabled! */
+ WriteServ(user->fd,"421 %s %s :This command has been disabled.",user->nick,command.c_str());
+ return;
}
- if ((user->registered == 7) || (cm->second == command_user) || (cm->second == command_nick) || (cm->second == command_pass))
+ if (items < cm->second->min_params)
+ {
+ WriteServ(user->fd,"461 %s %s :Not enough parameters.", user->nick, command.c_str());
+ /* If syntax is given, display this as the 461 reply */
+ if ((Config->SyntaxHints) && (cm->second->syntax.length()))
+ WriteServ(user->fd,"304 %s :SYNTAX %s %s", user->nick, cm->second->command.c_str(), cm->second->syntax.c_str());
+ return;
+ }
+ if ((user->registered == REG_ALL) || (cm->second == command_user) || (cm->second == command_nick) || (cm->second == command_pass))
{
/* ikky /stats counters */
cm->second->use_count++;
cm->second->total_bytes += cmd.length();
int MOD_RESULT = 0;
- FOREACH_RESULT(I_OnPreCommand,OnPreCommand(xcommand,command_p,items,user,true));
+ FOREACH_RESULT(I_OnPreCommand,OnPreCommand(command,command_p,items,user,true));
if (MOD_RESULT == 1)
return;
}
else
{
- WriteServ(user->fd,"451 %s :You have not registered",xcommand.c_str());
+ WriteServ(user->fd,"451 %s :You have not registered",command.c_str());
return;
}
}
else if (user)
{
ServerInstance->stats->statsUnknown++;
- WriteServ(user->fd,"421 %s %s :Unknown command",user->nick,xcommand.c_str());
+ WriteServ(user->fd,"421 %s %s :Unknown command",user->nick,command.c_str());
}
}
while ((a = buffer.find("\r")) != std::string::npos)
buffer.erase(a);
- log(DEBUG,"CMDIN: %s %s",user->nick,buffer.c_str());
-
- this->ProcessCommand(user,buffer);
+ if (buffer.length())
+ {
+ log(DEBUG,"CMDIN: %s %s",user->nick,buffer.c_str());
+ this->ProcessCommand(user,buffer);
+ }
}
bool CommandParser::CreateCommand(command_t *f)
projects / user / henk / code / inspircd.git / blobdiff