/*
============
Cmd_ExecTrigger
============
*/
void Cmd_ExecTrigger (char *string)
{
const cmd_trigger_t *trigger;
char *text;
// execute matching triggers
for(trigger = cmd_triggers; trigger; trigger = trigger->next)
{
text = Cmd_MacroExpandString(trigger->match);
if (text && wildcardfit (text, string))
{
Cbuf_AddText(trigger->command);
Cbuf_AddText("\n");
}
}
}
/*
============
Cmd_TokenizeString
Parses the given string into command line tokens.
$Cvars will be expanded unless they are in a quoted token
============
*/
void Cmd_TokenizeString (char *text, qboolean macroExpand)
{
int i;
char *com_token;
// clear the args from the last string
for (i=0 ; i<cmd_argc ; i++)
Z_Free (cmd_argv[i]);
cmd_argc = 0;
cmd_args[0] = 0;
// macro expand the text
if (macroExpand)
text = Cmd_MacroExpandString (text);
if (!text)
return;
while (1)
{
// skip whitespace up to a /n
while (*text && *text <= ' ' && *text != '\n')
{
text++;
}
if (*text == '\n')
{ // a newline seperates commands in the buffer
text++;
break;
}
if (!*text)
return;
// set cmd_args to everything after the first arg
if (cmd_argc == 1)
{
int l;
// sku - removed potentional buffer overflow
// vulnerability
strncpy( cmd_args, text, sizeof( cmd_args ) );
// strip off any trailing whitespace
l = strlen(cmd_args) - 1;
for ( ; l >= 0 ; l--)
if (cmd_args[l] <= ' ')
cmd_args[l] = 0;
else
break;
}
com_token = COM_Parse (&text);
if (!text)
return;
if (cmd_argc < MAX_STRING_TOKENS)
{
cmd_argv[cmd_argc] = (char *) Z_Malloc (strlen(com_token)+1);
strcpy (cmd_argv[cmd_argc], com_token);
cmd_argc++;
}
}
}
/*
* Parses the given string into command line tokens.
* $Cvars will be expanded unless they are in a quoted token
*/
void
Cmd_TokenizeString(char *text, qboolean macroExpand)
{
int i;
const char *com_token;
/* clear the args from the last string */
for (i = 0; i < cmd_argc; i++)
{
Z_Free(cmd_argv[i]);
}
cmd_argc = 0;
cmd_args[0] = 0;
/* macro expand the text */
if (macroExpand)
{
text = Cmd_MacroExpandString(text);
}
if (!text)
{
return;
}
while (1)
{
/* skip whitespace up to a /n */
while (*text && *text <= ' ' && *text != '\n')
{
text++;
}
if (*text == '\n')
{
/* a newline seperates commands in the buffer */
text++;
break;
}
if (!*text)
{
return;
}
/* set cmd_args to everything after the first arg */
if (cmd_argc == 1)
{
int l;
strcpy(cmd_args, text);
/* strip off any trailing whitespace */
l = strlen(cmd_args) - 1;
for ( ; l >= 0; l--)
{
if (cmd_args[l] <= ' ')
{
cmd_args[l] = 0;
}
else
{
break;
}
}
}
com_token = COM_Parse(&text);
if (!text)
{
return;
}
if (cmd_argc < MAX_STRING_TOKENS)
{
cmd_argv[cmd_argc] = Z_Malloc(strlen(com_token) + 1);
strcpy(cmd_argv[cmd_argc], com_token);
cmd_argc++;
}
}
}
/*
============
Cmd_TokenizeString
Parses the given string into command line tokens.
$Cvars will be expanded unless they are in a quoted token
R1CH: Modified this to avoid use of Z_Alloc/Z_Free. Using
dynamic memory functions for maybe 4-5 bytes at a time is
a waste...
============
*/
void Cmd_TokenizeString (char *text, qboolean macroExpand)
{
int cmd_pointer;
int i;
const char *com_token;
// clear the args from the last string
for (i=0 ; i<cmd_argc ; i++)
cmd_argv[i] = NULL;
//Z_Free (cmd_argv[i]);
cmd_argc = 0;
cmd_args[0] = 0;
cmd_pointer = 0;
// macro expand the text
if (macroExpand && strchr(text, '$'))
text = Cmd_MacroExpandString (text);
if (!text)
return;
for (;;)
{
// skip whitespace up to a /n
while (*text && (*text == '\t' || *text == ' ') && *text != '\n')
{
text++;
}
if (*text == '\n')
{ // a newline seperates commands in the buffer
text++;
break;
}
if (!*text)
return;
// set cmd_args to everything after the first arg
if (cmd_argc == 1)
{
int l;
strncpy (cmd_args, text, sizeof(cmd_args)-1);
// strip off any trailing whitespace
l = (int)strlen(cmd_args) - 1;
if (l == MAX_STRING_CHARS - 1) {
Com_Printf ("Cmd_TokenizeString: overflowed, possible attack detected.\nargv[0] = %s, remote = %s, len = %d\n", LOG_GENERAL|LOG_EXPLOIT,
cmd_argv[0], NET_AdrToString(&net_from), net_message.cursize);
return;
}
for ( ; l >= 0 ; l--)
if (cmd_args[l] <= ' ')
cmd_args[l] = 0;
else
break;
}
com_token = COM_Parse (&text);
if (!text)
return;
if (cmd_argc < MAX_STRING_TOKENS)
{
int len;
//cmd_argv[cmd_argc] = Z_TagMalloc (strlen(com_token)+1, TAGMALLOC_CMDTOKEN);
//strcpy (cmd_argv[cmd_argc], com_token);
len = (int)strlen(com_token);
if (len+1 + cmd_pointer >= MAX_STRING_CHARS*2)
{
Com_Printf ("Cmd_TokenizeString: overflow\n", LOG_GENERAL);
return;
}
strcpy (cmd_buffer + cmd_pointer, com_token);
cmd_argv[cmd_argc] = cmd_buffer + cmd_pointer;
cmd_argc++;
cmd_pointer += len+1;
}
}
}
/*
-----------------------------------------------------------------------------
Function: Cmd_TokenizeString -Parses the given string into command line tokens.
Parameters: text -[in] string to tokenize.
macroExpand -[in] Expand macro, true for yes, otherwise false.
Returns: Nothing
Notes:
$Cvars will be expanded unless they are in a quoted token
-----------------------------------------------------------------------------
*/
PUBLIC void Cmd_TokenizeString( char *text, _boolean macroExpand )
{
int i;
char *com_token;
// clear the args from the last string
for( i = 0 ; i < cmd_argc ; ++i )
{
Z_Free( cmd_argv[ i ] );
}
cmd_argc = 0;
cmd_args[ 0 ] = 0;
// macro expand the text
if( macroExpand )
{
text = Cmd_MacroExpandString( text );
}
if( ! text )
{
return;
}
while( 1 )
{
// skip whitespace up to a /n
while( *text && *text <= ' ' && *text != '\n' )
{
text++;
}
if( *text == '\n' )
{ // a newline seperates commands in the buffer
text++;
break;
}
if( ! *text )
{
return;
}
// set cmd_args to everything after the first arg
if( cmd_argc == 1 )
{
int l;
my_strlcpy( cmd_args, text, sizeof( cmd_args ) - 1 );
// strip off any trailing whitespace
l = strlen( cmd_args ) - 1;
for( ; l >= 0 ; --l )
{
if (cmd_args[l] <= ' ')
{
cmd_args[l] = 0;
}
else
{
break;
}
}
}
com_token = COM_Parse( &text );
if( ! text )
{
return;
}
if( cmd_argc < MAX_STRING_TOKENS )
{
cmd_argv[ cmd_argc ] = Z_Malloc( strlen( com_token ) + 1 );
my_strlcpy( cmd_argv[ cmd_argc ], com_token, strlen( com_token ) + 1 );
cmd_argc++;
}
}
}