bool CmdBrowser(char *szBrowser, bool bWait)
{
m_szBrowser = strmk(szBrowser);
m_bBrowserWait = bWait;
return true;
}
// UserGet: Find a given user
// iUserID - ID of the user to search for
// iSearchType - Flag for which search (0 = use szUserName, 1 = use iUserID)
// bReset - Flag for temporary position setting
bool UserGet(EDF *pData, int *iUserID, char **szUserName, int iSearchType, bool bReset, long lDate)
{
STACKTRACE
int iUserEDF = -1;
long lDateEDF = 0;
char *szUserEDF = NULL;
bool bLoop = true, bFound = false, bGetCopy = false;
if((iSearchType == 0 && (szUserName == NULL || *szUserName == NULL)) ||
(iSearchType == 1 && (iUserID == NULL || *iUserID <= 0)))
{
return false;
}
bGetCopy = pData->GetCopy(false);
if(bReset == true)
{
// Mark position for reset
pData->TempMark();
}
/* if(lDate != -1)
{
debug("UserGet userid %d (date %ld)\n", *iUserID, lDate);
} */
// Move to first user
pData->Root();
pData->Child("users");
bLoop = pData->Child("user");
while(bFound == false && bLoop == true)
{
if(lDate != -1 || pData->GetChildBool("deleted") == false)
{
if(iSearchType == 0)
{
// Search by name
pData->GetChild("name", &szUserEDF);
if(stricmp(*szUserName, szUserEDF) == 0)
{
// Set user ID return
pData->Get(NULL, iUserID);
strcpy(*szUserName, szUserEDF);
bFound = true;
}
}
else
{
// Search by ID
pData->Get(NULL, &iUserEDF);
if(*iUserID == iUserEDF)
{
if(szUserName != NULL)
{
// Set user name return
/* if(lDate != -1)
{
EDFPrint("UserGet historical pre check", pData, false);
} */
pData->Child("name", EDFElement::LAST);
pData->Get(NULL, &szUserEDF);
if(lDate != -1)
{
// Check historical names
// printf("UserGet current name %s\n", szUserEDF);
bLoop = pData->Prev("name");
while(bLoop == true)
{
lDateEDF = time(NULL);
pData->GetChild("date", &lDateEDF);
printf("UserGet historical check %ld", lDateEDF);
if(lDateEDF >= lDate)
{
pData->Get(NULL, &szUserEDF);
printf(". match %s", szUserEDF);
bLoop = pData->Prev("name");
}
else
{
bLoop = false;
}
printf("\n");
}
// printf("UserGet historical name %s\n", szUserEDF);
// EDFPrint("UserGet historial name post check", pData, false);
}
pData->Parent();
/* if(lDate != -1)
{
EDFPrint("UserGet historial name post check", pData, false);
} */
*szUserName = strmk(szUserEDF);
}
bFound = true;
}
}
}
if(bFound == false)
{
// Move to next child
bLoop = pData->Next("user");
}
}
if(bReset == true)
{
// Reset to marked position
pData->TempUnmark();
}
pData->GetCopy(bGetCopy);
return bFound;
}
char *CmdText(int iOptions, const char *szInit, CMDFIELDSFUNC pFieldsFunc, EDF *pData)
{
STACKTRACE
char *szInput = NULL, *szTempFile = NULL;
int iFile = 0;
CmdInput *pInput = NULL;
int iFork = 0, iReturn = -1;
struct stat sFile;
if(CmdEditor() != NULL && mask(iOptions, CMD_LINE_EDITOR) == true)
{
/* szTempFile = tempnam("/tmp", "qUAck");
// debug("CmdText temp file %s\n", szTempFile);
fFile = fopen(szTempFile, "w");
if(fFile != NULL) */
szTempFile = strmk("qUAckXXXXXXXX");
iFile = mkstemp(szTempFile);
if(iFile > 0)
{
// fclose(fFile);
debug(DEBUGLEVEL_INFO, "CmdText temp file %s\n", szTempFile);
iFork = fork();
if(iFork > 0)
{
STACKTRACEUPDATE
iReturn = wait(NULL);
debug(DEBUGLEVEL_DEBUG, "CmdText wait return %d\n", iReturn);
CmdRedraw(true);
}
else if(iFork == 0)
{
iReturn = execl(CmdEditor(), CmdEditor(), szTempFile, NULL);
if(iReturn == -1)
{
debug(DEBUGLEVEL_ERR, "CmdText exec failed, %s\n", strerror(errno));
}
}
else
{
debug(DEBUGLEVEL_ERR, "CmdText fork error, %s\n", strerror(errno));
}
}
else
{
debug(DEBUGLEVEL_ERR, "CmdText mkstemp failed, %s\n", strerror(errno));
}
STACKTRACEUPDATE
if(iReturn != -1)
{
if(CmdYesNo("Send message", true) == true)
{
fstat(iFile, &sFile);
szInput = new char[sFile.st_size + 1];
lseek(iFile, 0, SEEK_SET);
read(iFile, szInput, sFile.st_size);
szInput[sFile.st_size] = '\0';
debug(DEBUGLEVEL_DEBUG, "CmdText temp file '%s'\n", szInput);
}
}
if(iFile > 0)
{
close(iFile);
}
}
void CmdStartup(int iSignal)
{
bool bLoop = true, bEnvUser = false;
int cRead = 0, cCMD = 0, cOPT = 0, iEnvPos = 0, iEnvLen = 0;
unsigned char szEnv[50];
debug(DEBUGLEVEL_INFO, "CmdStartup entry %d\n", iSignal);
printf("%c%c%c%c%c%c%c%c%c", IAC, WILL, TELOPT_ECHO, IAC, WILL, TELOPT_SGA, IAC, DO, TELOPT_NEW_ENVIRON);
fflush(stdout);
while(bLoop == true)
{
cRead = CmdInputGet();
debug(DEBUGLEVEL_DEBUG, "CmdStartup read %d, length %d\n", cRead, CmdInputLen());
if(cRead == IAC && CmdInputLen() >= 2)
{
debug(DEBUGLEVEL_DEBUG, "CmdStartup IAC (%d more chars)", CmdInputLen(), cRead);
cCMD = CmdInputGet();
cOPT = CmdInputGet();
debug(DEBUGLEVEL_DEBUG, " [%d][%d]\n", cCMD, cOPT);
if(cCMD == WILL && cOPT == TELOPT_NEW_ENVIRON)
{
iEnvLen = 0;
szEnv[iEnvLen++] = IAC;
szEnv[iEnvLen++] = SB;
szEnv[iEnvLen++] = TELOPT_NEW_ENVIRON;
szEnv[iEnvLen++] = TELQUAL_SEND;
iEnvLen = CmdStartupEnv(szEnv, iEnvLen, NEW_ENV_VAR, "USER");
iEnvLen = CmdStartupEnv(szEnv, iEnvLen, ENV_USERVAR, "TERM");
// iEnvLen = CmdStartupEnv(szEnv, iEnvLen, ENV_USERVAR, "COLUMNS");
// iEnvLen = CmdStartupEnv(szEnv, iEnvLen, ENV_USERVAR, "LINES");
szEnv[iEnvLen++] = IAC;
szEnv[iEnvLen++] = SE;
debug(DEBUGLEVEL_DEBUG, "CmdStartup env request: ");
for(iEnvPos = 0; iEnvPos < iEnvLen; iEnvPos++)
{
if(isalnum(szEnv[iEnvPos]))
{
debug(DEBUGLEVEL_DEBUG, "%c", szEnv[iEnvPos]);
}
else
{
debug(DEBUGLEVEL_DEBUG, "[%d]", szEnv[iEnvPos]);
}
}
debug(DEBUGLEVEL_DEBUG, "\n");
fwrite(szEnv, sizeof(char), iEnvLen, stdout);
fflush(stdout);
// sleep(2);
}
else if(cCMD == SB && cOPT == TELOPT_NEW_ENVIRON)
{
debug(DEBUGLEVEL_DEBUG, "CmdStartup env settings\n");
cRead = CmdInputGet();
if(cRead == TELQUAL_IS)
{
iEnvPos = 0;
do
{
cRead = CmdInputGet();
if(cRead == IAC || cRead == NEW_ENV_VAR || cRead == ENV_USERVAR)
{
if(iEnvPos > 0)
{
szEnv[iEnvPos] = '\0';
debug(DEBUGLEVEL_DEBUG, ", value '%s'\n", szEnv);
if(bEnvUser == true)
{
g_szEnvUser = strmk((char *)szEnv);
bEnvUser = false;
}
}
// debug("CmdStartup env setting reset\n");
iEnvPos = 0;
}
else if(cRead == NEW_ENV_VALUE)
{
if(iEnvPos > 0)
{
szEnv[iEnvPos] = '\0';
debug(DEBUGLEVEL_DEBUG, "CmdStartup env '%s'", szEnv);
if(stricmp((char *)szEnv, "USER") == 0)
{
bEnvUser = true;
}
}
iEnvPos = 0;
}
else if(cRead == IAC)
{
cRead = CmdInputGet();
if(cRead == SE)
{
}
}
else
{
szEnv[iEnvPos++] = cRead;
}
} while(cRead != SE && CmdInputLen() > 0);
}
}
}
else
{
bLoop = false;
}
}
debug(DEBUGLEVEL_DEBUG, "CmdStartup %d chars in buffer\n", CmdInputLen());
CmdWidth(80);
CmdHeight(25);
m_bStartup = false;
debug(DEBUGLEVEL_INFO, "CmdStartup exit\n");
}
// Internal channel get method
bool ChannelGet(EDF *pData, int *iChannelID, char **szChannelName, int iSearchType, bool bReset)
{
STACKTRACE
int iChannelEDF = -1;
char *szChannelEDF = NULL;
bool bLoop = true, bFound = false, bGetCopy = false;
if((iSearchType == 0 && (szChannelName == NULL || *szChannelName == NULL)) ||
(iSearchType == 1 && (iChannelID == NULL || *iChannelID <= 0)))
{
return false;
}
bGetCopy = pData->GetCopy(false);
if(bReset == true)
{
pData->TempMark();
}
// Position to first channel
pData->Root();
pData->Child("channels");
bLoop = pData->Child("channel");
while(bFound == false && bLoop == true)
{
if(iSearchType == 0)
{
// Search by name
pData->GetChild("name", &szChannelEDF);
if(stricmp(*szChannelName, szChannelEDF) == 0)
{
// Set channel ID return (make a copy of the name)
pData->Get(NULL, iChannelID);
strcpy(*szChannelName, szChannelEDF);
bFound = true;
}
}
else
{
// Search by ID
pData->Get(NULL, &iChannelEDF);
if(*iChannelID == iChannelEDF)
{
if(szChannelName != NULL)
{
// Set channel name return (use a copy)
pData->GetChild("name", &szChannelEDF);
*szChannelName = strmk(szChannelEDF);
}
bFound = true;
}
}
if(bFound == false)
{
bLoop = pData->Iterate("channel", "channels");
}
}
if(bReset == true)
{
pData->TempUnmark();
}
pData->GetCopy(bGetCopy);
return bFound;
}
EDF *QueryToEDF(char *szQuery)
{
int iValue = 0;
bool bLiteral = false, bNot = false;
char cQuote = '\0';
char *szPos = szQuery, *szStart = NULL, *szToken = NULL, *szChr = NULL, *szCommand = NULL, *szValue = NULL, *szName = NULL;
EDF *pEDF = NULL, *pReturn = NULL;
EDFElement *pElement = NULL, *pDelete = NULL;
printf("QueryToEDF entry '%s'\n", szQuery);
pEDF = new EDF();
pEDF->Set("and");
while(*szPos != '\0' && (*szPos == ' ' || *szPos == '\t' || *szPos == '\n'))
{
szPos++;
}
while(*szPos != '\0')
{
printf("QueryToEDF loop %d %c\n", szPos - szQuery, *szPos);
if(*szPos == '(')
{
printf("QueryToEDF open bracket\n");
if(bNot == true)
{
pEDF->Add("not");
bNot = false;
}
pEDF->Add("and");
szPos++;
}
else if(*szPos == ')')
{
EDFParser::Print("QueryToEDF close bracket", pEDF, EDFElement::EL_CURR | EDFElement::PR_SPACE);
if(pEDF->Children() == 0)
{
pEDF->Delete();
}
else if(pEDF->Children() == 1)
{
EDFParser::Print("QueryToEDF pre delete", pEDF, EDFElement::EL_CURR | EDFElement::PR_SPACE);
pEDF->Child();
pElement = pEDF->GetCurr();
pEDF->Parent();
pDelete = pEDF->GetCurr();
pEDF->Parent();
pEDF->MoveFrom(pElement);
pEDF->SetCurr(pDelete);
pEDF->Delete();
EDFParser::Print("QueryToEDF post delete", pEDF, EDFElement::EL_CURR | EDFElement::PR_SPACE);
}
else
{
pEDF->Parent();
}
pEDF->Get(&szName);
if(strcmp(szName, "not") == 0)
{
pEDF->Parent();
}
delete[] szName;
szPos++;
}
else
{
if(*szPos == '"' || *szPos == '\'')
{
cQuote = *szPos;
szPos++;
}
else
{
cQuote = '\0';
}
szStart = szPos;
if(cQuote != '\0')
{
bLiteral = false;
// while(*szPos != '\0' && !(bLiteral == false && *szPos == cQuote));
while(*szPos != '\0' && *szPos != cQuote)
{
/* if(*szPos == '\\')
{
bLiteral = true;
}
else
{
bLiteral = false;
} */
szPos++;
}
}
else
{
while(*szPos != '\0' && isspace(*szPos) == 0 && *szPos != '(' && *szPos != ')')
{
szPos++;
}
}
szToken = strmk(szQuery, szStart - szQuery, szPos - szQuery);
// printf("%-*sQueryToEDF token '%s'\n", iIndent, "", szToken);
if(cQuote != '\0')
{
szPos++;
}
szChr = strchr(szToken, ':');
if(szChr != NULL)
{
szCommand = strmk(szToken, 0, szChr - szToken);
szValue = strmk(szChr + 1);
iValue = atoi(szValue);
printf("QueryToEDF command %s: '%s' / %d\n", szCommand, szValue, iValue);
if(bNot == true)
{
pEDF->Add("not");
}
if(stricmp(szCommand, "folder") == 0 || stricmp(szCommand, "folderid") == 0)
{
pEDF->AddChild("folderid", iValue);
}
else if(stricmp(szCommand, "from") == 0 || stricmp(szCommand, "fromid") == 0)
{
pEDF->AddChild("fromid", iValue);
}
else if(stricmp(szCommand, "to") == 0 || stricmp(szCommand, "toid") == 0)
{
pEDF->AddChild("toid", iValue);
}
else if(stricmp(szCommand, "user") == 0 || stricmp(szCommand, "userid") == 0)
{
pEDF->Add("or");
pEDF->AddChild("fromid", iValue);
pEDF->AddChild("toid", iValue);
pEDF->Parent();
}
if(bNot == true)
{
pEDF->Parent();
bNot = false;
}
delete[] szCommand;
delete[] szValue;
}
else
{
if(stricmp(szToken, "and") == 0 || stricmp(szToken, "or") == 0)
{
printf("QueryToEDF logical %s\n", szToken);
pEDF->Set(szToken);
}
else if(stricmp(szToken, "not") == 0)
{
bNot = true;
}
else
{
printf("QueryToEDF keyword '%s'\n", szToken);
pEDF->AddChild("keyword", szToken);
}
}
delete[] szToken;
}
if(isspace(*szPos) != 0)
{
do
{
szPos++;
}
while(*szPos != '\0' && isspace(*szPos) != 0);
}
}
pReturn = new EDF();
pReturn->Copy(pEDF);
delete pEDF;
EDFParser::Print("QueryToEDF exit", pReturn);
return pReturn;
}
