* ---------------------------------------------------
*/
-using namespace std;
-
#include "inspircd_config.h"
#include "inspircd.h"
-#include "inspircd_io.h"
+#include "configreader.h"
#include <unistd.h>
#include <fcntl.h>
#include <sys/errno.h>
#include <sys/utsname.h>
#include <time.h>
#include <string>
-#ifdef GCC3
-#include <ext/hash_map>
-#else
-#include <hash_map>
-#endif
-#include <map>
#include <sstream>
#include <vector>
-#include <deque>
#include <sched.h>
#ifdef THREADED_DNS
#include <pthread.h>
extern user_hash clientlist;
extern chan_hash chanlist;
+/* Special commands which may occur without registration of the user */
+cmd_user* command_user;
+cmd_nick* command_nick;
+cmd_pass* command_pass;
+
/* This function pokes and hacks at a parameter list like the following:
*
* PART #winbot,#darkgalaxy :m00!
int CommandParser::LoopCall(command_t* fn, char **parameters, int pcnt, userrec *u, int start, int end, int joins)
{
- char plist[MAXBUF];
+ /* 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
+ */
char *pars[32];
- char blog[32][MAXBUF];
- char blog2[32][MAXBUF];
- int j = 0, q = 0, total = 0, t = 0, t2 = 0, total2 = 0;
- char keystr[MAXBUF];
- char moo[MAXBUF];
-
- for (int i = 0; i <32; i++)
- {
- *blog[i] = 0;
- *blog2[i] = 0;
- }
-
- *moo = 0;
- for (int i = 0; i <10; i++)
+ /* Seperated items, e.g. holds the #one and #two from "#one,#two"
+ */
+ char *sep_items[32];
+ /* Seperated keys, holds the 'two' and 'three' of "two,three"
+ */
+ 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.
+ */
+ char nothing = 0;
+
+ /* First, initialize our arrays */
+ for (int i = 0; i < 32; i++)
+ sep_items[i] = sep_keys[i] = NULL;
+
+ /* Now find all parameters that are NULL, maybe above pcnt,
+ * and for safety, point them at 'nothing'
+ */
+ for (int i = 0; i < 10; i++)
{
if (!parameters[i])
{
- parameters[i] = moo;
+ 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.
+ */
if (joins)
{
if (pcnt > 1) /* we have a key to copy */
{
- strlcpy(keystr,parameters[1],MAXBUF);
+ strlcpy(keylist,parameters[1],MAXBUF);
}
}
+ /* There's nothing to split! We don't do anything
+ */
if (!parameters[start] || (!strchr(parameters[start],',')))
{
return 0;
}
- *plist = 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(plist,parameters[i],MAXBUF);
+ 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 = plist;
+ param = paramlist;
- t = strlen(plist);
-
- for (int i = 0; i < t; i++)
+ for (char* i = paramlist; *i; i++)
{
- if (plist[i] == ',')
+ /* Found an item */
+ if (*i == ',')
{
- plist[i] = '\0';
- strlcpy(blog[j++],param,MAXBUF);
- param = plist+i+1;
+ *i = '\0';
+ sep_items[j++] = param;
+ /* Iterate along to next item, if there is one */
+ param = i+1;
if ((unsigned int)j > Config->MaxTargets)
{
- WriteServ(u->fd,"407 %s %s :Too many targets in list, message not delivered.",u->nick,blog[j-1]);
+ /* 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;
}
}
}
-
- strlcpy(blog[j++],param,MAXBUF);
+ sep_items[j++] = param;
total = j;
- if ((joins) && (keystr) && (total>0)) // more than one channel and is joining
+ /* 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)
+ */
+ if ((joins) && (*keylist) && (total>0)) // more than one channel and is joining
{
- strcat(keystr,",");
+ charlcat(keylist,',',MAXBUF);
}
- if ((joins) && (keystr))
+ /* 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))
{
- if (strchr(keystr,','))
+ /* There is more than one key */
+ if (strchr(keylist,','))
{
j = 0;
- param = keystr;
- t2 = strlen(keystr);
-
- for (int i = 0; i < t2; i++)
+ param = keylist;
+ for (char* i = keylist; *i; i++)
{
- if (keystr[i] == ',')
+ if (*i == ',')
{
- keystr[i] = '\0';
- strlcpy(blog2[j++],param,MAXBUF);
- param = keystr+i+1;
+ *i = '\0';
+ sep_keys[j++] = param;
+ param = i+1;
}
}
- strlcpy(blog2[j++],param,MAXBUF);
+ sep_keys[j++] = param;
total2 = j;
}
}
+ /* Now the easier bit. We call the command class's Handle function
+ * X times, where x is the number of parameters we've 'collated'.
+ */
for (j = 0; j < total; j++)
{
- if (blog[j])
+ if (sep_items[j])
{
- pars[0] = blog[j];
+ pars[0] = sep_items[j];
}
for (q = end; q < pcnt-1; q++)
{
if (pcnt > 1)
{
- pars[1] = blog2[j];
+ pars[1] = sep_keys[j];
}
else
{
{
if (pars[1])
{
- // pars[1] already set up and containing key from blog2[j]
+ /* pars[1] already set up and containing key from sep_keys[j] */
fn->Handle(pars,2,u);
}
else
return 1;
}
-bool CommandParser::IsValidCommand(std::string &commandname, int pcnt, userrec * user)
+bool CommandParser::IsValidCommand(const std::string &commandname, int pcnt, userrec * user)
{
nspace::hash_map<std::string,command_t*>::iterator n = cmdlist.find(commandname);
{
if (n->second->flags_needed)
{
- if ((user->HasPermission(commandname)) || (is_uline(user->server)))
- {
- return true;
- }
- else
- {
- return false;
- }
+ return ((user->HasPermission(commandname)) || (is_uline(user->server)));
}
-
return true;
}
}
}
-
return false;
}
// calls a handler function for a command
-bool CommandParser::CallHandler(std::string &commandname,char **parameters, int pcnt, userrec *user)
+bool CommandParser::CallHandler(const std::string &commandname,char **parameters, int pcnt, userrec *user)
{
nspace::hash_map<std::string,command_t*>::iterator n = cmdlist.find(commandname);
int CommandParser::ProcessParameters(char **command_p,char *parameters)
{
int j = 0;
- int q = strlen(parameters);
- if (!q)
+ if (!*parameters)
{
/* no parameters, command_p invalid! */
return 0;
}
- if (parameters[0] == ':')
+ if (*parameters == ':')
{
command_p[0] = parameters+1;
return 1;
}
- if (q)
+ if (*parameters)
{
- if ((strchr(parameters,' ')==NULL) || (parameters[0] == ':'))
+ char* n = strchr(parameters,' ');
+ if ((!n) || (*parameters == ':'))
{
/* only one parameter */
command_p[0] = parameters;
- if (parameters[0] == ':')
+ if (*parameters == ':')
{
- if (strchr(parameters,' ') != NULL)
+ if (n)
{
command_p[0]++;
}
command_p[j++] = parameters;
- for (int i = 0; i <= q; i++)
+ for (char* i = parameters; *i; i++)
{
- if (parameters[i] == ' ')
+ if (*i == ' ')
{
- command_p[j++] = parameters+i+1;
- parameters[i] = '\0';
+ command_p[j++] = i+1;
+ *i = '\0';
- if (command_p[j-1][0] == ':')
+ if (*command_p[j-1] == ':')
{
*command_p[j-1]++; /* remove dodgy ":" */
break;
}
}
}
-
return j; /* returns total number of items in the list */
}
char p[MAXBUF], temp[MAXBUF];
int j, items, cmd_found;
int total_params = 0;
- unsigned int xl;
for (int i = 0; i < 127; i++)
command_p[i] = NULL;
return;
}
- xl = strlen(cmd);
+ char* first_space = NULL;
- if (xl > 2)
+ /* If the command is > 2 characters (quick and dirty way to find out) */
+ if (*cmd && *(cmd+1) && *(cmd+2))
{
- for (unsigned int q = 0; q < xl - 1; q++)
+ for (char* q = cmd; *q; q++)
{
- if (cmd[q] == ' ')
+ if (*q == ' ')
{
- if (cmd[q+1] == ':')
+ first_space = q;
+ if (*(q+1) == ':')
{
total_params++;
// found a 'trailing', we dont count them after this.
// another phidjit bug...
if (total_params > 126)
{
- *(strchr(cmd,' ')) = '\0';
+ *first_space = 0;
WriteServ(user->fd,"421 %s %s :Too many parameters given",user->nick,cmd);
return;
}
strlcpy(cmd,tmp.c_str(),MAXBUF);
strlcpy(temp,cmd,MAXBUF);
- if (!strchr(cmd,' '))
+ char* has_space = strchr(cmd,' ');
+ int cm_length = 0;
+ if (!has_space)
{
/*
* no parameters, lets skip the formalities and not chop up
items = 0;
command_p[0] = NULL;
parameters = NULL;
- unsigned int tl = strlen(cmd);
- for (unsigned int i = 0; i <= tl; i++)
- {
- cmd[i] = toupper(cmd[i]);
- }
+ for (char* i = cmd; *i; i++,cm_length++)
+ *i = toupper(*i);
command = cmd;
}
else
*cmd = 0;
j = 0;
- unsigned int vl = strlen(temp);
/* strip out extraneous linefeeds through mirc's crappy pasting (thanks Craig) */
- for (unsigned int i = 0; i < vl; i++)
+ for (char* i = temp; *i; i++)
{
- if ((temp[i] != 10) && (temp[i] != 13) && (temp[i] != 0) && (temp[i] != 7))
+ if ((*i != 10) && (*i != 13) && (*i != 0) && (*i != 7))
{
- cmd[j++] = temp[i];
- cmd[j] = 0;
+ cmd[j++] = *i;
}
}
+ cmd[j] = 0;
/* split the full string into a command plus parameters */
parameters = p;
command = cmd;
- if (strchr(cmd,' '))
+ if (has_space)
{
- unsigned int cl = strlen(cmd);
-
- for (unsigned int i = 0; i <= cl; i++)
+ for (char* i = cmd; *i; i++)
{
/* capitalise the command ONLY, leave params intact */
- cmd[i] = toupper(cmd[i]);
+ *i = toupper(*i);
/* are we nearly there yet?! :P */
- if (cmd[i] == ' ')
+ if (*i == ' ')
{
command = cmd;
- parameters = cmd+i+1;
- cmd[i] = '\0';
+ parameters = i+1;
+ *i = 0;
break;
}
}
}
else
{
- for (char* i = cmd; *i; i++)
+ for (char* i = cmd; *i; i++,cm_length++)
{
*i = toupper(*i);
}
}
}
- if (strlen(command)>MAXCOMMAND)
+ if (cm_length > MAXCOMMAND)
{
WriteServ(user->fd,"421 %s %s :Command too long",user->nick,command);
return;
}
/* if the command isnt USER, PASS, or NICK, and nick is empty,
* deny command! */
- if ((strncmp(command,"USER",4)) && (strncmp(command,"NICK",4)) && (strncmp(command,"PASS",4)))
+ if ((cm->second != command_user) && (cm->second != command_nick) && (cm->second != command_pass))
{
if ((!isnick(user->nick)) || (user->registered != 7))
{
}
}
}
- if ((user->registered == 7) || (!strncmp(command,"USER",4)) || (!strncmp(command,"NICK",4)) || (!strncmp(command,"PASS",4)))
+ if ((user->registered == 7) || (cm->second == command_user) || (cm->second == command_nick) || (cm->second == command_pass))
{
/* ikky /stats counters */
if (temp)
{
char cmd[MAXBUF];
- if (!user)
- {
- log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
- return;
- }
- if (!cmdbuf)
+ if (!user || !cmdbuf || !*cmdbuf)
{
log(DEFAULT,"*** BUG *** process_buffer was given an invalid parameter");
return;
}
- if (!cmdbuf[0])
- {
- return;
- }
while (*cmdbuf == ' ') cmdbuf++; // strip leading spaces
- strlcpy(cmd,cmdbuf,MAXBUF);
-
- if (!cmd[0])
- {
+ if (!*cmdbuf)
return;
- }
+
+ strlcpy(cmd,cmdbuf,MAXBUF);
+ while (charremove(cmd,10));
+ while (charremove(cmd,13));
- /* XXX - This is ugly as sin, and incomprehensible - why are we doing this twice, for instance? --w00t */
int sl = strlen(cmd)-1;
-
- if ((cmd[sl] == 13) || (cmd[sl] == 10))
+ while (sl && (cmd[sl] == ' ')) // strip trailing spaces
{
- cmd[sl] = '\0';
+ cmd[sl--] = 0;
}
- sl = strlen(cmd)-1;
-
- if ((cmd[sl] == 13) || (cmd[sl] == 10))
- {
- cmd[sl] = '\0';
- }
-
- sl = strlen(cmd)-1;
-
-
- while (cmd[sl] == ' ') // strip trailing spaces
- {
- cmd[sl] = '\0';
- sl = strlen(cmd)-1;
- }
-
- if (!cmd[0])
- {
+ if (!sl)
return;
- }
log(DEBUG,"CMDIN: %s %s",user->nick,cmd);
+
tidystring(cmd);
- if ((user) && (cmd))
+
+ if (user && cmd)
{
this->ProcessCommand(user,cmd);
}
void CommandParser::SetupCommandTable()
{
- this->CreateCommand(new cmd_user);
- this->CreateCommand(new cmd_nick);
+ /* These three are special (can occur without
+ * full user registration) and so are saved
+ * for later use.
+ */
+ command_user = new cmd_user;
+ command_nick = new cmd_nick;
+ command_pass = new cmd_pass;
+ this->CreateCommand(command_user);
+ this->CreateCommand(command_nick);
+ this->CreateCommand(command_pass);
+
+ /* The rest of these arent special. boo hoo.
+ */
this->CreateCommand(new cmd_quit);
this->CreateCommand(new cmd_version);
this->CreateCommand(new cmd_ping);
this->CreateCommand(new cmd_summon);
this->CreateCommand(new cmd_users);
this->CreateCommand(new cmd_invite);
- this->CreateCommand(new cmd_pass);
this->CreateCommand(new cmd_trace);
this->CreateCommand(new cmd_whowas);
this->CreateCommand(new cmd_connect);
this->CreateCommand(new cmd_server);
this->CreateCommand(new cmd_commands);
}
-
projects / user / henk / code / inspircd.git / blobdiff