149 lines
3.2 KiB
C
149 lines
3.2 KiB
C
/*
|
|
parse.c
|
|
|
|
Handles input commands from clients, by splitting strings into tokens
|
|
and passing arguments to the appropriate handler.
|
|
|
|
It works much like a command line. Only the first token is used to
|
|
determine what function to call.
|
|
|
|
*/
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "../shared/LL.h"
|
|
#include "../shared/sockets.h"
|
|
#include "../shared/debug.h"
|
|
#include "clients.h"
|
|
#include "client_functions.h"
|
|
#include "parse.h"
|
|
|
|
|
|
|
|
int parse_all_client_messages()
|
|
{
|
|
int i, j;
|
|
int newtoken, inquote;
|
|
client *c;
|
|
char *str;
|
|
// char *tok;
|
|
int argc;
|
|
char *argv[256];
|
|
char delimiters[] = " \0";
|
|
char leftquote[] = "\0\"'`([{\0";
|
|
char rightquote[] = "\0\"'`)]}\0";
|
|
char errmsg[256];
|
|
int invalid=0;
|
|
|
|
//debug("parse: Rewinding list...\n");
|
|
LL_Rewind(clients);
|
|
do {
|
|
// Get the next client...
|
|
//debug("parse: Getting client...\n");
|
|
c = LL_Get(clients);
|
|
if(c)
|
|
{
|
|
// And parse all its messages...
|
|
//debug("parse: Getting messages...\n");
|
|
for(str = client_get_message(c); str; str = client_get_message(c))
|
|
{
|
|
debug("parse: ...%s\n", str);
|
|
// Now, split up the string...
|
|
//len = strlen(str);
|
|
argc=0;
|
|
newtoken=1;
|
|
inquote=0;
|
|
for(i=0; str[i]; i++)
|
|
{
|
|
if(inquote) // Scan for the end of the quote
|
|
{
|
|
if(str[i] == rightquote[inquote])
|
|
{ // Found the end of the quote
|
|
inquote=0;
|
|
str[i] = 0;
|
|
newtoken=1;
|
|
}
|
|
}
|
|
else // Normal operation; split at delimiters
|
|
{
|
|
for(j=1; leftquote[j]; j++)
|
|
{
|
|
// Found the beginning of a new quote...
|
|
if(str[i] == leftquote[j])
|
|
{
|
|
inquote = j;
|
|
str[i] = 0;
|
|
continue;
|
|
}
|
|
}
|
|
for(j=0; delimiters[j]; j++)
|
|
{
|
|
// Break into a new string...
|
|
if(str[i] == delimiters[j])
|
|
{
|
|
str[i] = 0;
|
|
newtoken = 1;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if(newtoken && str[i])
|
|
{
|
|
newtoken=0;
|
|
argv[argc] = str + i;
|
|
argc++;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
if(inquote)
|
|
{
|
|
sprintf(errmsg, "huh? Unterminated string: missing %c\n",
|
|
rightquote[inquote]);
|
|
sock_send_string(c->sock, errmsg);
|
|
continue;
|
|
}
|
|
/*
|
|
for(tok = strtok(str, delimiters);
|
|
tok;
|
|
tok=strtok(NULL, delimiters))
|
|
{
|
|
argv[argc] = tok;
|
|
argc++;
|
|
}
|
|
*/
|
|
argv[argc] = NULL;
|
|
if(argc < 1) continue;
|
|
|
|
// Now find and call the appropriate function...
|
|
// debug("parse: Finding function...\n");
|
|
invalid = 1;
|
|
for(i=0; commands[i].keyword; i++)
|
|
{
|
|
// debug("(checking %s)\n", commands[i].keyword);
|
|
if(0 == strcmp(argv[0], commands[i].keyword))
|
|
{
|
|
// debug("(FOUND %s)\n", commands[i].keyword);
|
|
invalid = commands[i].function(c, argc, argv);
|
|
// debug("parse: Returned %i...\n", err);
|
|
}
|
|
}
|
|
if(invalid)
|
|
{
|
|
// FIXME: Check for buffer overflows here...
|
|
sprintf(errmsg, "huh? Invalid command \"%s\"\n", argv[0]);
|
|
sock_send_string(c->sock, errmsg);
|
|
}
|
|
|
|
free(str); // fixed memory leak?
|
|
} // end for(str...)
|
|
} // end if (c)
|
|
} while (LL_Next(clients) == 0);
|
|
|
|
return 0;
|
|
}
|