int CConsole::ParseStart(CResult *pResult, const char *pString, int Length)
{
char *pStr;
int Len = sizeof(pResult->m_aStringStorage);
if(Length < Len)
Len = Length;
str_copy(pResult->m_aStringStorage, pString, Len);
pStr = pResult->m_aStringStorage;
// get command
pStr = str_skip_whitespaces(pStr);
pResult->m_pCommand = pStr;
pStr = str_skip_to_whitespace(pStr);
if(*pStr)
{
pStr[0] = 0;
pStr++;
}
pResult->m_pArgsStart = pStr;
return 0;
}
const char *CUnpacker::GetString(int SanitizeType)
{
if(m_Error || m_pCurrent >= m_pEnd)
return "";
char *pPtr = (char *)m_pCurrent;
while(*m_pCurrent) // skip the string
{
m_pCurrent++;
if(m_pCurrent == m_pEnd)
{
m_Error = 1;;
return "";
}
}
m_pCurrent++;
// sanitize all strings
if(SanitizeType&SANITIZE)
str_sanitize(pPtr);
else if(SanitizeType&SANITIZE_CC)
str_sanitize_cc(pPtr);
return SanitizeType&SKIP_START_WHITESPACES ? str_skip_whitespaces(pPtr) : pPtr;
}
int CConsole::ParseArgs(CResult *pResult, const char *pFormat)
{
char Command;
char *pStr;
int Optional = 0;
int Error = 0;
pStr = pResult->m_pArgsStart;
while(1)
{
// fetch command
Command = *pFormat;
pFormat++;
if(!Command)
break;
if(Command == '?')
Optional = 1;
else
{
pStr = str_skip_whitespaces(pStr);
if(!(*pStr)) // error, non optional command needs value
{
if(!Optional)
Error = 1;
break;
}
// add token
if(*pStr == '"')
{
char *pDst;
pStr++;
pResult->AddArgument(pStr);
pDst = pStr; // we might have to process escape data
while(1)
{
if(pStr[0] == '"')
break;
else if(pStr[0] == '\\')
{
if(pStr[1] == '\\')
pStr++; // skip due to escape
else if(pStr[1] == '"')
pStr++; // skip due to escape
}
else if(pStr[0] == 0)
return 1; // return error
*pDst = *pStr;
pDst++;
pStr++;
}
// write null termination
*pDst = 0;
pStr++;
}
else
{
pResult->AddArgument(pStr);
if(Command == 'r') // rest of the string
break;
else if(Command == 'i') // validate int
pStr = str_skip_to_whitespace(pStr);
else if(Command == 'f') // validate float
pStr = str_skip_to_whitespace(pStr);
else if(Command == 's') // validate string
pStr = str_skip_to_whitespace(pStr);
if(pStr[0] != 0) // check for end of string
{
pStr[0] = 0;
pStr++;
}
}
}
}
return Error;
}
void CConsole::ExecuteLineStroked(int Stroke, const char *_pStr)
{
/* The following feature makes it possible to execute commands on key release
making it possible to do binds such as:
bind f "cl_nameplates 1; cl_nameplates_always 1 | cl_nameplates 0; cl_nameplates_always 0"
which will show nameplates for the time of pressing the key */
const char *pStr = _pStr;
{
const char* ptr;
if(!Stroke) { // on release try to handle other part of the command
if((ptr = str_find(pStr, "|")) != NULL) {
pStr = ptr + 1;
Stroke = 1; // treat a non stroke command as a stroke one
}
}
pStr = str_skip_whitespaces((char*)pStr);
}
while(pStr && *pStr)
{
CResult *pResult = new(&m_ExecutionQueue.m_pLast->m_Result) CResult;
const char *pEnd = pStr;
const char *pNextPart = 0;
int InString = 0;
while(*pEnd)
{
if(*pEnd == '"')
InString ^= 1;
else if(*pEnd == '\\') // escape sequences
{
if(pEnd[1] == '"')
pEnd++;
}
else if(!InString)
{
if(*pEnd == ';') // command separator
{
pNextPart = pEnd+1;
break;
}
else if(*pEnd == '#') // comment, no need to do anything more
break;
else if(*pEnd == '|') // the other part of the string is handled
break; //on the begining of the function
}
pEnd++;
}
if(ParseStart(pResult, pStr, (pEnd-pStr) + 1) != 0)
return;
CCommand *pCommand = FindCommand(pResult->m_pCommand, m_FlagMask);
if(pCommand)
{
int IsStrokeCommand = 0;
if(pResult->m_pCommand[0] == '+')
{
// insert the stroke direction token
pResult->AddArgument(m_paStrokeStr[Stroke]);
IsStrokeCommand = 1;
}
if(Stroke || IsStrokeCommand)
{
if(ParseArgs(pResult, pCommand->m_pParams))
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "Invalid arguments... Usage: %s %s", pCommand->m_pName, pCommand->m_pParams);
Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);
}
else if(m_StoreCommands && pCommand->m_Flags&CFGFLAG_STORE)
{
m_ExecutionQueue.m_pLast->m_pfnCommandCallback = pCommand->m_pfnCallback;
m_ExecutionQueue.m_pLast->m_pCommandUserData = pCommand->m_pUserData;
m_ExecutionQueue.AddEntry();
}
else
pCommand->m_pfnCallback(pResult, pCommand->m_pUserData);
}
}
else if(Stroke)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "No such command: %s.", pResult->m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);
}
pStr = pNextPart;
}
}
int CMain::HandleMessage(int ClientNetID, char *pMessage)
{
CClient *pClient = ClientNet(ClientNetID);
if(!pClient)
return true;
if(str_comp_num(pMessage, "update", sizeof("update")-1) == 0)
{
char *pData = str_skip_whitespaces(&pMessage[sizeof("update")-1]);
// parse json data
json_settings JsonSettings;
mem_zero(&JsonSettings, sizeof(JsonSettings));
char aError[256];
json_value *pJsonData = json_parse_ex(&JsonSettings, pData, strlen(pData), aError);
if(!pJsonData)
{
dbg_msg("main", "JSON Error: %s", aError);
if(pClient->m_Stats.m_Pong)
m_Server.Network()->Send(ClientNetID, "1");
return 1;
}
// extract data
const json_value &rStart = (*pJsonData);
if(rStart["uptime"].type)
pClient->m_Stats.m_Uptime = rStart["uptime"].u.integer;
if(rStart["load"].type)
pClient->m_Stats.m_Load = rStart["load"].u.dbl;
if(rStart["network_rx"].type)
pClient->m_Stats.m_NetworkRx = rStart["network_rx"].u.integer;
if(rStart["network_tx"].type)
pClient->m_Stats.m_NetworkTx = rStart["network_tx"].u.integer;
if(rStart["memory_total"].type)
pClient->m_Stats.m_MemTotal = rStart["memory_total"].u.integer;
if(rStart["memory_used"].type)
pClient->m_Stats.m_MemUsed = rStart["memory_used"].u.integer;
if(rStart["hdd_total"].type)
pClient->m_Stats.m_HDDTotal = rStart["hdd_total"].u.integer;
if(rStart["hdd_used"].type)
pClient->m_Stats.m_HDDUsed = rStart["hdd_used"].u.integer;
if(rStart["cpu"].type)
pClient->m_Stats.m_CPU = rStart["cpu"].u.dbl;
if(rStart["online4"].type && pClient->m_ClientNetType == NETTYPE_IPV6)
pClient->m_Stats.m_Online4 = rStart["online4"].u.boolean;
if(rStart["online6"].type && pClient->m_ClientNetType == NETTYPE_IPV4)
pClient->m_Stats.m_Online6 = rStart["online6"].u.boolean;
if(m_Config.m_Verbose)
{
if(rStart["online4"].type)
dbg_msg("main", "Online4: %s\nUptime: %" PRId64 "\nLoad: %lf\nNetworkRx: %" PRId64 "\nNetworkTx: %" PRId64 "\nMemTotal: %" PRId64 "\nMemUsed: %" PRId64 "\nHDDTotal: %" PRId64 "\nHDDUsed: %" PRId64 "\nCPU: %lf\n",
rStart["online4"].u.boolean ? "true" : "false",
pClient->m_Stats.m_Uptime, pClient->m_Stats.m_Load, pClient->m_Stats.m_NetworkRx, pClient->m_Stats.m_NetworkTx, pClient->m_Stats.m_MemTotal, pClient->m_Stats.m_MemUsed, pClient->m_Stats.m_HDDTotal, pClient->m_Stats.m_HDDUsed, pClient->m_Stats.m_CPU);
else if(rStart["online6"].type)
dbg_msg("main", "Online6: %s\nUptime: %" PRId64 "\nLoad: %lf\nNetworkRx: %" PRId64 "\nNetworkTx: %" PRId64 "\nMemTotal: %" PRId64 "\nMemUsed: %" PRId64 "\nHDDTotal: %" PRId64 "\nHDDUsed: %" PRId64 "\nCPU: %lf\n",
rStart["online6"].u.boolean ? "true" : "false",
pClient->m_Stats.m_Uptime, pClient->m_Stats.m_Load, pClient->m_Stats.m_NetworkRx, pClient->m_Stats.m_NetworkTx, pClient->m_Stats.m_MemTotal, pClient->m_Stats.m_MemUsed, pClient->m_Stats.m_HDDTotal, pClient->m_Stats.m_HDDUsed, pClient->m_Stats.m_CPU);
else
dbg_msg("main", "Uptime: %" PRId64 "\nLoad: %lf\nNetworkRx: %" PRId64 "\nNetworkTx: %" PRId64 "\nMemTotal: %" PRId64 "\nMemUsed: %" PRId64 "\nHDDTotal: %" PRId64 "\nHDDUsed: %" PRId64 "\nCPU: %lf\n",
pClient->m_Stats.m_Uptime, pClient->m_Stats.m_Load, pClient->m_Stats.m_NetworkRx, pClient->m_Stats.m_NetworkTx, pClient->m_Stats.m_MemTotal, pClient->m_Stats.m_MemUsed, pClient->m_Stats.m_HDDTotal, pClient->m_Stats.m_HDDUsed, pClient->m_Stats.m_CPU);
}
// clean up
json_value_free(pJsonData);
if(pClient->m_Stats.m_Pong)
m_Server.Network()->Send(ClientNetID, "0");
return 0;
}
else if(str_comp_num(pMessage, "pong", sizeof("pong")-1) == 0)
{
char *pData = str_skip_whitespaces(&pMessage[sizeof("pong")-1]);
if(!str_comp(pData, "0") || !str_comp(pData, "off"))
pClient->m_Stats.m_Pong = false;
else if(!str_comp(pData, "1") || !str_comp(pData, "on"))
pClient->m_Stats.m_Pong = true;
return 0;
}
if(pClient->m_Stats.m_Pong)
m_Server.Network()->Send(ClientNetID, "1");
return 1;
}