bool ReadDegFile(const char * inFile)
{
MFMemFile * f = NULL;
MFTextScanner * s = NULL;
bool ok = false;
f = MemFile_Open(inFile);
if (f == NULL) goto bail;
s = TextScanner_Open(f);
if (s == NULL) goto bail;
while (!TextScanner_IsDone(s))
{
const char * l = TextScanner_GetBegin(s);
if (*l != '#')
{
FAAObs_t obs;
char buf[256];
if (sscanf(l, "%lf %lf %f %f %s",
&obs.lon, &obs.lat, &obs.msl, &obs.agl, buf) == 5)
{
// printf("Got: %lf %lf %f %f %s\n",
// obs.lon, obs.lat, obs.msl, obs.agl, buf);
obs.kind = LookupToken(buf);
gFAAObs.insert(FAAObsTable::value_type(HashLonLat(obs.lon, obs.lat), obs));
}
}
TextScanner_Next(s);
}
ok = true;
bail:
if (s) TextScanner_Close(s);
if (f) MemFile_Close(f);
return ok;
}
int ParseConfigSearchAndWrite(TCHAR *pszLine, CONFIG *pConfig)
{
int iStart;
int iLen;
OPTIONS sO;
TCHAR *pszSearch;
TCHAR *pszWrite;
unsigned char *pucArgumentSearch;
int iBytesSearch;
unsigned char *pucArgumentWrite;
int iBytesWrite;
struct CommandSearchAndWrite *pCSAW;
int iTokenArgument;
iStart = GetToken(0, pszLine, &iLen, NULL);
if (-1 == iStart)
return -1;
ZeroMemory(&sO, sizeof(OPTIONS));
sO.bModule = TRUE;
sO.bMemory = TRUE;
iStart = ParseOptions(pszLine+iStart, &sO);
if (-1 == iStart)
return -1;
if (NULL != sO.pszModule && NULL != sO.pszMemory)
return -1;
if (!TwoRemainingTokens(pszLine+iStart, &pszSearch, &pszWrite))
return -1;
iTokenArgument = ParseArgument(pszSearch, &pucArgumentSearch, &iBytesSearch);
free(pszSearch);
if (0 == iBytesSearch || (TOK_HEX != iTokenArgument && TOK_ASCII != iTokenArgument && TOK_UNICODE != iTokenArgument))
return -1;
iTokenArgument = ParseArgument(pszWrite, &pucArgumentWrite, &iBytesWrite);
free(pszWrite);
if (0 == iBytesWrite || (TOK_HEX != iTokenArgument && TOK_ASCII != iTokenArgument && TOK_UNICODE != iTokenArgument))
return -1;
pCSAW = malloc(sizeof(struct CommandSearchAndWrite));
if (NULL == pCSAW)
return -1;
pCSAW->searchLen = iBytesSearch;
pCSAW->searchBytes = pucArgumentSearch;
pCSAW->writeLen = iBytesWrite;
pCSAW->writeBytes = pucArgumentWrite;
pCSAW->pszModule = sO.pszModule;
if (NULL != sO.pszMemory)
if (TOK_WRITABLE == LookupToken(sO.pszMemory))
pCSAW->dwMemory = PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY|PAGE_READWRITE|PAGE_WRITECOPY;
else
return -1;
else
pCSAW->dwMemory = 0;
return AddStatement(pConfig, COMMAND_SEARCH_AND_WRITE, pCSAW);
}
int WINAPI LookupTokens(TableEntry* psTable_, char* pszTokens_)
{
int n = 0;
char *pszStart = pszTokens_;
char *pszEnd = pszTokens_;
for (;;) {
if (*pszEnd == '\0') {
n |= LookupToken(psTable_, pszStart);
break;
}
if (*pszEnd == '|') {
*pszEnd = '\0';
n |= LookupToken(psTable_, pszStart);
*pszEnd = '|';
pszStart = pszEnd + 1;
}
pszEnd++;
}
return n;
}
int ParseConfigAdjustTokenPrivileges(TCHAR *pszLine, CONFIG *pConfig)
{
TCHAR *pszToken;
int iToken;
if (!OneRemainingToken(pszLine, &pszToken))
return -1;
iToken = LookupToken(pszToken);
free(pszToken);
if (TOK_ME != iToken)
return -2;
return AddStatement(pConfig, COMMAND_ADJUST_TOKE_PRIVILEGES, NULL);
}
DWORD ParseAddress(TCHAR *pszAddress)
{
DWORD dwAddress;
TCHAR *pszPrefix;
TCHAR *pszValue;
if (ParseStringColonString(pszAddress, &pszPrefix, &pszValue))
return 0;
if (TOK_HEX == LookupToken(pszPrefix))
sscanf(pszValue, "%8x", &dwAddress); //a// check hex
else
dwAddress = 0;
free(pszPrefix);
free(pszValue);
return dwAddress;
}
TCHAR *ParseFilename(TCHAR *pszToken)
{
TCHAR *pszPrefix;
TCHAR *pszValue;
TCHAR *pszCurrentDirectory;
TCHAR *pszResult;
int iLen;
if (ParseStringColonString(pszToken, &pszPrefix, &pszValue))
return _tcsdup(pszToken);
if (TOK_CURRENTDIRECTORY != LookupToken(pszPrefix))
{
free(pszPrefix);
free(pszValue);
return _tcsdup(pszToken);
}
free(pszPrefix);
pszCurrentDirectory = malloc(MAX_PATH);
if (NULL == pszCurrentDirectory)
{
free(pszValue);
return NULL;
}
if (!GetCurrentDirectory(MAX_PATH, pszCurrentDirectory))
{
free(pszCurrentDirectory);
free(pszValue);
return NULL;
}
iLen = (_tcslen(pszCurrentDirectory)+1+_tcslen(pszValue)+1)*sizeof(TCHAR);
pszResult = malloc(iLen);
if (NULL == pszResult)
{
free(pszCurrentDirectory);
free(pszValue);
return NULL;
}
_sntprintf(pszResult, iLen, "%s\\%s", pszCurrentDirectory, pszValue);
return pszResult;
}
int WINAPI LookupTokens(TableEntry* psTable_, char* pszTokens_)
{
int n = 0;
char *pszStart = pszTokens_;
char *pszEnd = pszTokens_;
for (;;) {
char c = *pszEnd;
if (c == '|' || c == '\0') {
*pszEnd = '\0';
n |= LookupToken(psTable_, pszStart);
*pszEnd = c;
if (!c)
break;
pszStart = ++pszEnd;
}
else
pszEnd = CharNext(pszEnd);
}
return n;
}
int WINAPI ReadSettings(void) {
static char szField[25];
int nIdx, nCtrlIdx;
pszTitle = myGetProfileStringDup("Settings", "Title");
pszCancelButtonText = myGetProfileStringDup("Settings", "CancelButtonText");
pszNextButtonText = myGetProfileStringDup("Settings", "NextButtonText");
pszBackButtonText = myGetProfileStringDup("Settings", "BackButtonText");
nNumFields = myGetProfileInt("Settings", "NumFields", 0);
nRectId = myGetProfileInt("Settings", "Rect", DEFAULT_RECT);
bBackEnabled = myGetProfileInt("Settings", "BackEnabled", -1);
// by ORTIM: 13-August-2002
bCancelEnabled = myGetProfileInt("Settings", "CancelEnabled", -1);
bCancelShow = myGetProfileInt("Settings", "CancelShow", -1);
bRTL = myGetProfileInt("Settings", "RTL", 0);
if (nNumFields > 0) {
// make this twice as large for the worst case that every control is a browse button.
// the structure is small enough that this won't waste much memory.
// if the structure gets much larger, we should switch to a linked list.
pFields = (FieldType *)MALLOC(sizeof(FieldType)*2*nNumFields);
}
for (nIdx = 0, nCtrlIdx = 0; nCtrlIdx < nNumFields; nCtrlIdx++, nIdx++) {
// Control types
static TableEntry TypeTable[] = {
{ "LABEL", FIELD_LABEL },
{ "TEXT", FIELD_TEXT },
{ "PASSWORD", FIELD_TEXT },
{ "LISTBOX", FIELD_LISTBOX },
{ "COMBOBOX", FIELD_COMBOBOX },
{ "DROPLIST", FIELD_COMBOBOX },
{ "FILEREQUEST", FIELD_FILEREQUEST },
{ "DIRREQUEST", FIELD_DIRREQUEST },
{ "CHECKBOX", FIELD_CHECKBOX },
{ "RADIOBUTTON", FIELD_RADIOBUTTON },
{ "ICON", FIELD_ICON },
{ "BITMAP", FIELD_BITMAP },
{ "GROUPBOX", FIELD_GROUPBOX },
#ifdef IO_ENABLE_LINK
{ "LINK", FIELD_LINK },
#else
{ "LINK", FIELD_LABEL },
#endif
{ "BUTTON", FIELD_BUTTON },
{ NULL, 0 }
};
// Control flags
static TableEntry FlagTable[] = {
{ "NOTIFY", LBS_NOTIFY },
{ "WARN_IF_EXIST", OFN_OVERWRITEPROMPT },
{ "FILE_HIDEREADONLY", OFN_HIDEREADONLY },
{ "MULTISELECT", LBS_MULTIPLESEL },
{ "READONLY", FLAG_READONLY },
{ "RIGHT", BS_LEFTTEXT },
{ "PASSWORD", FLAG_PASSWORD },
{ "ONLY_NUMBERS", FLAG_ONLYNUMBERS },
{ "MULTILINE", FLAG_MULTILINE },
{ "NOWORDWRAP", FLAG_NOWORDWRAP },
{ "WANTRETURN", FLAG_WANTRETURN },
{ "EXTENDEDSELCT", LBS_EXTENDEDSEL },
{ "PATH_MUST_EXIST", OFN_PATHMUSTEXIST },
{ "FILE_MUST_EXIST", OFN_FILEMUSTEXIST },
{ "PROMPT_CREATE", OFN_CREATEPROMPT },
{ "DROPLIST", FLAG_DROPLIST },
{ "RESIZETOFIT", FLAG_RESIZETOFIT },
{ "NOTABSTOP", WS_TABSTOP },
{ "GROUP", WS_GROUP },
{ "REQ_SAVE", FLAG_SAVEAS },
{ "FILE_EXPLORER", OFN_EXPLORER },
{ "HSCROLL", WS_HSCROLL },
{ "VSCROLL", WS_VSCROLL },
{ "DISABLED", WS_DISABLED },
{ NULL, 0 }
};
FieldType *pField = pFields + nIdx;
wsprintf(szField, "Field %d", nCtrlIdx + 1);
// Get the control type
myGetProfileString(szField, "TYPE");
pField->nType = LookupToken(TypeTable, szResult);
if (pField->nType == FIELD_INVALID)
continue;
// Lookup flags associated with the control type
pField->nFlags = LookupToken(FlagTable, szResult);
myGetProfileString(szField, "Flags");
pField->nFlags |= LookupTokens(FlagTable, szResult);
// pszState must not be NULL!
myGetProfileString(szField, "State");
pField->pszState = strdup(szResult);
// ListBox items list
{
int nResult = myGetProfileString(szField, "ListItems");
if (nResult) {
// add an extra | character to the end to simplify the loop where we add the items.
pField->pszListItems = (char*)MALLOC(nResult + 2);
strcpy(pField->pszListItems, szResult);
pField->pszListItems[nResult] = '|';
pField->pszListItems[nResult + 1] = '\0';
}
}
// Label Text - convert newline
pField->pszText = myGetProfileStringDup(szField, "TEXT");
if (pField->nType == FIELD_LABEL)
ConvertNewLines(pField->pszText);
// Dir request - root folder
pField->pszRoot = myGetProfileStringDup(szField, "ROOT");
// ValidateText - convert newline
pField->pszValidateText = myGetProfileStringDup(szField, "ValidateText");
ConvertNewLines(pField->pszValidateText);
{
int nResult = GetPrivateProfileString(szField, "Filter", "All Files|*.*", szResult, sizeof(szResult), pszFilename);
if (nResult) {
// Convert the filter to the format required by Windows: NULL after each
// item followed by a terminating NULL
pField->pszFilter = (char*)MALLOC(nResult + 2);
strcpy(pField->pszFilter, szResult);
char *pszPos = pField->pszFilter;
while (*pszPos) {
if (*pszPos == '|') *pszPos = '\0';
pszPos++;
}
}
}
pField->rect.left = myGetProfileInt(szField, "LEFT", 0);
pField->rect.top = myGetProfileInt(szField, "TOP", 0);
pField->rect.right = myGetProfileInt(szField, "RIGHT", 0);
pField->rect.bottom = myGetProfileInt(szField, "BOTTOM", 0);
pField->nMinLength = myGetProfileInt(szField, "MinLen", 0);
pField->nMaxLength = myGetProfileInt(szField, "MaxLen", 0);
// Text color for LINK control, default is pure blue
pField->hImage = (HANDLE)myGetProfileInt(szField, "TxtColor", RGB(0,0,255));
pField->nControlID = 1200 + nIdx;
if (pField->nType == FIELD_FILEREQUEST || pField->nType == FIELD_DIRREQUEST)
{
FieldType *pNewField = &pFields[nIdx+1];
pNewField->nControlID = 1200 + nIdx + 1;
pNewField->nType = FIELD_BROWSEBUTTON;
pNewField->nFlags = pField->nFlags & (WS_DISABLED | WS_TABSTOP);
pNewField->pszText = STRDUP(szBrowseButtonCaption); // needed for generic FREE
pNewField->rect.right = pField->rect.right;
pNewField->rect.left = pNewField->rect.right - BROWSE_WIDTH;
pNewField->rect.bottom = pField->rect.bottom;
pNewField->rect.top = pField->rect.top;
pField->rect.right = pNewField->rect.left - 3;
nNumFields++;
nIdx++;
}
}
return nNumFields;
}
//a// Release Memory!
int ParseConfigStrings(TCHAR *pszLine, CONFIG *pConfig)
{
OPTIONS sO;
int iStart;
struct CommandStrings *pCS;
ZeroMemory(&sO, sizeof(OPTIONS));
sO.bModule = TRUE;
sO.bAddress = TRUE;
sO.bMinimumLength = TRUE;
sO.bStartAddress = TRUE;
sO.bEndAddress = TRUE;
sO.bAlphaPercentage = TRUE;
sO.bRegex = TRUE;
sO.bFilter = TRUE;
sO.bMemory = TRUE;
iStart = ParseOptions(pszLine, &sO);
if (iStart != -1)
return -1;
if (NULL != sO.pszModule && NULL != sO.pszMemory)
return -7;
pCS = malloc(sizeof(struct CommandStrings));
if (NULL == pCS)
return -1;
pCS->pszModule = sO.pszModule;
if (NULL != sO.pszAddress)
switch(LookupToken(sO.pszAddress))
{
case TOK_ON:
pCS->bAddress = TRUE;
break;
case TOK_OFF:
pCS->bAddress = FALSE;
break;
default:
return -2;
}
else
pCS->bAddress = FALSE;
if (NULL != sO.pszMinimumLength)
{
if (ParseUnsignedNumber(sO.pszMinimumLength, &(pCS->uiMinimumLength)) < 0)
return -3;
}
else
pCS->uiMinimumLength = 4;
if (NULL != sO.pszStartAddress)
{
sscanf(sO.pszStartAddress, "%8x", &(pCS->dwStartAddress)); //a// check hex
}
else
pCS->dwStartAddress = 0;
if (NULL != sO.pszEndAddress)
{
sscanf(sO.pszEndAddress, "%8x", &(pCS->dwEndAddress)); //a// check hex
}
else
pCS->dwEndAddress = 0xFFFFFFFF;
if (NULL != sO.pszAlphaPercentage)
{
if (ParseUnsignedNumber(sO.pszAlphaPercentage, &(pCS->uiAlphaPercentage)) < 0)
return -4;
if (pCS->uiAlphaPercentage > 100)
return -5;
}
else
pCS->uiAlphaPercentage = 0;
pCS->pszRegex = sO.pszRegex;
pCS->pPCRE = NULL;
pCS->pszFilter = sO.pszFilter;
if (NULL != sO.pszMemory)
if (TOK_WRITABLE == LookupToken(sO.pszMemory))
pCS->dwMemory = PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY|PAGE_READWRITE|PAGE_WRITECOPY;
else
return -6;
else
pCS->dwMemory = 0;
return AddStatement(pConfig, COMMAND_STRINGS, pCS);
}
int ParseArgument(TCHAR *pszToken, unsigned char **ppucBuffer, int *piSize)
{
TCHAR *pszPrefix;
TCHAR *pszValue;
int iToken;
int iIter;
int iByte;
char szByte[3];
if (ParseStringColonString(pszToken, &pszPrefix, &pszValue))
return 0;
iToken = LookupToken(pszPrefix);
free(pszPrefix);
switch(iToken)
{
case TOK_HEX:
*piSize = _tcslen(pszValue)/sizeof(TCHAR)/2;
*ppucBuffer = malloc(*piSize);
if (*ppucBuffer == NULL)
{
free(pszValue);
return 0;
}
szByte[2] = TCHAR_NULL;
for (iIter=0; iIter<*piSize; iIter++)
{
szByte[0] = pszValue[iIter*2];
szByte[1] = pszValue[iIter*2+1];
sscanf(szByte, "%2x", &iByte);
(*ppucBuffer)[iIter] = (unsigned char) iByte;
}
break;
case TOK_UNICODE:
*piSize = _tcslen(pszValue)/sizeof(TCHAR)*2;
*ppucBuffer = malloc(*piSize);
if (*ppucBuffer == NULL)
{
free(pszValue);
return 0;
}
for (iIter=0; iIter<*piSize/2; iIter++)
{
(*ppucBuffer)[iIter*2] = (unsigned char) pszValue[iIter];
(*ppucBuffer)[iIter*2+1] = '\0';
}
break;
case TOK_ASCII:
*piSize = _tcslen(pszValue)/sizeof(TCHAR);
*ppucBuffer = malloc(*piSize);
if (*ppucBuffer == NULL)
return 0;
_tcsncpy(*ppucBuffer, pszValue, *piSize);
break;
case TOK_FILE:
*piSize = _tcslen(pszValue)/sizeof(TCHAR) + 1;
*ppucBuffer = pszValue;
break;
default:
iToken = 0;
}
return iToken;
}
int ParseLine(TCHAR *pszLine, CONFIG *pConfig)
{
int len;
int start;
TCHAR *pszToken;
int iToken;
Chomp(pszLine);
start = GetToken(0, pszLine, &len, &pszToken);
if (start == -1) // empty line or comment line
return 0;
iToken = LookupToken(pszToken);
free(pszToken);
switch (iToken)
{
case TOK_DLL_NAME:
return ParseConfigDLLName(pszLine+start+len, pConfig);
case TOK_PROCESS_NAME:
return ParseConfigProcessName(pszLine+start+len, pConfig);
case TOK_PID:
return ParseConfigPID(pszLine+start+len, pConfig);
case TOK_VERBOSE:
return ParseConfigVerbose(pszLine+start+len, pConfig);
case TOK_START:
return ParseConfigStart(pszLine+start+len, pConfig);
case TOK_WRITE:
return ParseConfigWrite(pszLine+start+len, pConfig);
case TOK_SEARCH_AND_WRITE:
return ParseConfigSearchAndWrite(pszLine+start+len, pConfig);
case TOK_PAUSE:
return ParseConfigPause(pszLine+start+len, pConfig);
case TOK_CONFIRM:
return ParseConfigConfirm(pszLine+start+len, pConfig);
case TOK_DUMP:
return ParseConfigDump(pszLine+start+len, pConfig);
case TOK_INJECT_DLL:
return ParseConfigInjectDLL(pszLine+start+len, pConfig);
case TOK_REJECT_DLL:
return ParseConfigRejectDLL(pszLine+start+len, pConfig);
case TOK_INFO:
return ParseConfigInfo(pszLine+start+len, pConfig);
case TOK_READONLY:
return ParseConfigReadOnly(pszLine+start+len, pConfig);
case TOK_SUSPEND:
return ParseConfigSuspend(pszLine+start+len, pConfig);
case TOK_RESUME:
return ParseConfigResume(pszLine+start+len, pConfig);
case TOK_PRINT:
return ParseConfigPrint(pszLine+start+len, pConfig);
case TOK_ADJUST_TOKE_PRIVILEGES:
return ParseConfigAdjustTokenPrivileges(pszLine+start+len, pConfig);
case TOK_STRINGS:
return ParseConfigStrings(pszLine+start+len, pConfig);
case TOK_DISABLE_CONSOLE_OUTPUT:
return ParseConfigDisableConsoleOutput(pszLine+start+len, pConfig);
case TOK_OUTPUT_TO_FILE:
return ParseConfigOutputToFile(pszLine+start+len, pConfig);
case TOK_PLUGIN:
return ParseConfigPlugin(pszLine+start+len, pConfig);
case TOK_REPEAT:
return ParseConfigRepeat(pszLine+start+len, pConfig);
case TOK_TEST_FUNCTION:
return ParseConfigTestFunction(pszLine+start+len, pConfig);
case TOK_INJECT_CODE:
return ParseConfigInjectCode(pszLine+start+len, pConfig);
}
return -1;
}
int ParseConfigInjectCode(TCHAR *pszLine, CONFIG *pConfig)
{
TCHAR *pszToken;
struct CommandInjectCode *pCInjectCode;
unsigned char *pucBytes;
int iBytes;
OPTIONS sO;
int iStart;
int iTokenArgument;
ZeroMemory(&sO, sizeof(OPTIONS));
sO.bMinimumLength = TRUE;
sO.bExecute = TRUE;
iStart = ParseOptions(pszLine, &sO);
if (iStart < 0)
return -1;
if (!OneRemainingToken(pszLine+iStart, &pszToken))
return -2;
iTokenArgument = ParseArgument(pszToken, &pucBytes, &iBytes);
free(pszToken);
if (0 == iBytes || (TOK_HEX != iTokenArgument && TOK_ASCII != iTokenArgument && TOK_UNICODE != iTokenArgument && TOK_FILE != iTokenArgument))
{
free(pucBytes);
return -3;
}
pCInjectCode = malloc(sizeof(struct CommandInjectCode));
if (NULL == pCInjectCode)
{
free(pucBytes);
return -4;
}
pCInjectCode->pbBytes = pucBytes;
pCInjectCode->lBytesSize = iBytes;
pCInjectCode->bFilename = TOK_FILE == iTokenArgument;
if (NULL != sO.pszMinimumLength)
{
if (ParseUnsignedNumber(sO.pszMinimumLength, &(pCInjectCode->uiMinimumBytesSize)) < 0)
return -5;
}
else
pCInjectCode->uiMinimumBytesSize = 0;
if (NULL != sO.pszExecute)
switch(LookupToken(sO.pszExecute))
{
case TOK_YES:
pCInjectCode->bExecute = TRUE;
break;
case TOK_NO:
pCInjectCode->bExecute = FALSE;
break;
default:
return -2;
}
else
pCInjectCode->bExecute = TRUE;
return AddStatement(pConfig, COMMAND_INJECT_CODE, pCInjectCode);
}
