/********************************************************************
Desc: Edit Text
*********************************************************************/
FLMBOOL ViewEditText(
const char * pszPrompt,
char * pszText,
FLMUINT uiTextLen,
FLMBOOL * pbValEntered)
{
char szTempBuf [100];
FLMUINT uiNumCols;
FLMUINT uiNumRows;
f_conGetScreenSize( &uiNumCols, &uiNumRows);
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
ViewAskInput( pszPrompt, szTempBuf, sizeof( szTempBuf) - 1);
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
if (f_stricmp( szTempBuf, "\\") == 0)
{
*pbValEntered = FALSE;
return( FALSE);
}
if( !szTempBuf[ 0])
{
*pbValEntered = FALSE;
return( TRUE);
}
if (f_strlen( szTempBuf) >= uiTextLen)
{
szTempBuf [uiTextLen - 1] = 0;
}
f_strcpy( pszText, szTempBuf);
*pbValEntered = TRUE;
return( TRUE);
}
/***************************************************************************
Desc: This routine displays an error message to the screen.
*****************************************************************************/
void ViewShowError(
const char * pszMessage)
{
FLMUINT uiChar;
FLMUINT uiNumCols;
FLMUINT uiNumRows;
f_conGetScreenSize( &uiNumCols, &uiNumRows);
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
f_conSetBackFore( FLM_RED, FLM_WHITE);
f_conStrOutXY( pszMessage, 0, uiNumRows - 2);
f_conStrOutXY( "Press ENTER to continue: ", 0, uiNumRows - 1);
for (;;)
{
uiChar = f_conGetKey();
if (uiChar == FKB_ENTER || uiChar == FKB_ESCAPE)
{
break;
}
}
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
ViewEscPrompt();
}
/********************************************************************
Desc: ?
*********************************************************************/
FSTATIC void bldShowError(
const char * Message)
{
if( !gv_bBatchMode)
{
f_conSetBackFore( FLM_BLACK, FLM_LIGHTGRAY);
f_conClearScreen( 0, 22);
f_conSetBackFore( FLM_RED, FLM_WHITE);
f_conStrOutXY( Message, 0, 22);
f_conStrOutXY( "Press any character to continue, ESCAPE to quit: ", 0, 23);
for (;;)
{
if (gv_bShutdown)
{
break;
}
else if (f_conHaveKey())
{
if (f_conGetKey() == FKB_ESCAPE)
{
gv_bShutdown = TRUE;
}
break;
}
f_yieldCPU();
}
f_conSetBackFore( FLM_BLACK, FLM_LIGHTGRAY);
f_conClearScreen( 0, 22);
}
}
/********************************************************************
Desc: ?
*********************************************************************/
FSTATIC RCODE bldGetUserInput(
void
)
{
FLMUINT uiChar;
f_conStrOutXY( "Q,ESC=Quit, Other=Continue: ", 0, 23);
for (;;)
{
if( gv_bShutdown)
{
uiChar = FKB_ESCAPE;
break;
}
else if( f_conHaveKey())
{
uiChar = f_conGetKey();
if( uiChar)
{
break;
}
}
f_yieldCPU();
}
f_conSetBackFore( FLM_BLACK, FLM_LIGHTGRAY);
f_conClearScreen( 0, 22);
switch( uiChar)
{
case 'q':
case 'Q':
case FKB_ESCAPE:
return( RC_SET( FERR_FAILURE));
default:
break;
}
return( FERR_OK);
}
/********************************************************************
Desc: Get a number from the user
*********************************************************************/
FLMBOOL ViewGetNum(
const char * pszPrompt,
void * pvNum,
FLMBOOL bEnterHexFlag,
FLMUINT uiNumBytes,
FLMUINT64 ui64MaxValue,
FLMBOOL * pbValEntered)
{
FLMBOOL bOk = FALSE;
char szTempBuf[ 20];
FLMUINT uiLoop;
FLMUINT uiChar;
FLMBOOL bGetOK;
FLMUINT64 ui64Num;
FLMUINT uiMaxDigits;
FLMUINT uiNumCols;
FLMUINT uiNumRows;
f_conGetScreenSize( &uiNumCols, &uiNumRows);
if (bEnterHexFlag)
{
uiMaxDigits = uiNumBytes * 2;
}
else
{
uiMaxDigits = (uiNumBytes == 8
? 20
: (uiNumBytes == 4
? 10
: (uiNumBytes == 2
? 5
: 3)));
}
for (;;)
{
bGetOK = TRUE;
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
ViewAskInput( pszPrompt, szTempBuf, sizeof( szTempBuf));
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
if (f_stricmp( szTempBuf, "\\") == 0)
{
*pbValEntered = FALSE;
goto Exit;
}
if( !szTempBuf[ 0])
{
*pbValEntered = FALSE;
bOk = TRUE;
goto Exit;
}
uiLoop = 0;
ui64Num = 0;
while (szTempBuf[ uiLoop] && uiLoop < uiMaxDigits)
{
uiChar = szTempBuf[ uiLoop];
if (bEnterHexFlag)
{
ui64Num <<= 4;
if (uiChar >= '0' && uiChar <= '9')
{
ui64Num += (FLMUINT64)(uiChar - '0');
}
else if (uiChar >= 'a' && uiChar <= 'f')
{
ui64Num += (FLMUINT64)(uiChar - 'a' + 10);
}
else if (uiChar >= 'A' && uiChar <= 'F')
{
ui64Num += (FLMUINT64)(uiChar - 'A' + 10);
}
else
{
ViewShowError(
"Illegal digit in number - must be hex digits");
bGetOK = FALSE;
break;
}
}
else if (uiChar < '0' || uiChar > '9')
{
ViewShowError(
"Illegal digit in number - must be 0 through 9");
bGetOK = FALSE;
break;
}
else
{
if (ui64MaxValue / 10 < ui64Num)
{
ViewShowError( "Number is too large");
bGetOK = FALSE;
break;
}
else
{
ui64Num *= 10;
if (ui64MaxValue - (FLMUINT64)(uiChar - '0') < ui64Num)
{
ViewShowError( "Number is too large");
bGetOK = FALSE;
break;
}
else
{
ui64Num += (FLMUINT64)(uiChar - '0');
}
}
}
uiLoop++;
}
if (bGetOK)
{
if (uiNumBytes == 8)
{
*((FLMUINT64 *)(pvNum)) = ui64Num;
}
else if (uiNumBytes == 4)
{
*((FLMUINT32 *)(pvNum)) = (FLMUINT32)ui64Num;
}
else if( uiNumBytes == 2)
{
*((FLMUINT16 *)(pvNum)) = (FLMUINT16)ui64Num;
}
else
{
*((FLMBYTE *)(pvNum)) = (FLMBYTE)ui64Num;
}
*pbValEntered = TRUE;
bOk = TRUE;
goto Exit;
}
}
Exit:
return( bOk);
}
/********************************************************************
Desc: Edit binary data
*********************************************************************/
FLMBOOL ViewEditBinary(
const char * pszPrompt,
FLMBYTE * pucBuf,
FLMUINT * puiByteCount,
FLMBOOL * pbValEntered)
{
FLMUINT uiMaxBytes = *puiByteCount;
FLMUINT uiByteCount;
FLMBOOL bOdd;
char szTempBuf [300];
FLMUINT uiLoop;
FLMUINT uiNumCols;
FLMUINT uiNumRows;
f_conGetScreenSize( &uiNumCols, &uiNumRows);
if (!pszPrompt)
{
pszPrompt = "Enter Binary Values (in hex): ";
}
for (;;)
{
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
ViewAskInput( pszPrompt, szTempBuf, sizeof( szTempBuf));
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
if( f_stricmp( szTempBuf, "\\") == 0)
{
*pbValEntered = FALSE;
return( FALSE);
}
if (!szTempBuf[ 0])
{
*pbValEntered = FALSE;
return( TRUE);
}
bOdd = FALSE;
uiByteCount = 0;
uiLoop = 0;
while (szTempBuf [uiLoop])
{
FLMBYTE ucValue;
ucValue = szTempBuf [uiLoop];
if (ucValue >= '0' && ucValue <= '9')
{
ucValue -= '0';
}
else if (ucValue >= 'a' && ucValue <= 'f')
{
ucValue = ucValue - 'a' + 10;
}
else if (ucValue >= 'A' && ucValue <= 'F')
{
ucValue = ucValue - 'A' + 10;
}
else if (ucValue == ' ' || ucValue == '\t')
{
bOdd = FALSE;
uiLoop++;
continue;
}
else
{
uiByteCount = 0;
ViewShowError( "Non-HEX digits are illegal");
break;
}
// If we get here, we have another digit
if (bOdd)
{
bOdd = FALSE;
(*pucBuf) <<= 4;
(*pucBuf) |= ucValue;
}
else
{
if (uiByteCount == uiMaxBytes)
{
break;
}
// Don't increment pucBuf the first time through
if (uiByteCount)
{
pucBuf++;
}
uiByteCount++;
*pucBuf = ucValue;
bOdd = TRUE;
}
uiLoop++;
}
if (!uiByteCount)
{
if (!szTempBuf[ uiLoop])
{
ViewShowError( "No HEX digits entered");
}
}
else if (szTempBuf[ uiLoop])
{
ViewShowError( "Too many digits entered");
}
else
{
*puiByteCount = uiByteCount;
*pbValEntered = TRUE;
return( TRUE);
}
}
}
/********************************************************************
Desc: ?
*********************************************************************/
FSTATIC FLMBOOL bldDoRebuild( void)
{
RCODE rc;
FLMBOOL bOk = TRUE;
char szErrMsg[ 100];
CREATE_OPTS createOpts;
gv_ui64DatabaseSize = 0;
gv_ui64BytesDone = 0;
gv_uiDictRecsRecovered = 0;
gv_iLastDoing = -1;
gv_uiTotalRecs = 0;
gv_uiRecsRecovered = 0;
f_conSetBackFore( FLM_BLACK, FLM_LIGHTGRAY);
f_conClearScreen( 0, 0);
gv_bLoggingEnabled = FALSE;
gv_uiLogBufferCount = 0;
if( gv_szLogFileName[ 0])
{
gv_pFileSystem->deleteFile( gv_szLogFileName);
if (RC_OK( rc = gv_pFileSystem->createFile(
gv_szLogFileName, FLM_IO_RDWR, &gv_pLogFile)))
{
gv_bLoggingEnabled = TRUE;
}
else
{
f_strcpy( szErrMsg, "Error creating log file: ");
f_strcpy( &szErrMsg[ f_strlen( szErrMsg)], FlmErrorString( rc));
bldShowError( szErrMsg);
bOk = FALSE;
goto Exit;
}
}
/* Configure FLAIM */
if (RC_BAD( rc = FlmConfig( FLM_CACHE_LIMIT,
(void *)(gv_uiCacheSize * 1024), (void *)0)))
{
f_strcpy( szErrMsg, "Error setting cache size for FLAIM share: ");
f_strcpy( &szErrMsg[ f_strlen( szErrMsg)], FlmErrorString( rc));
bldShowError( szErrMsg);
bOk = FALSE;
goto Exit;
}
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
if( gv_bLoggingEnabled)
{
bldLogString( NULL);
bldLogString( NULL);
bldLogString( NULL);
bldLogString(
"==========================================================================");
bldLogString( "REBUILD PARAMETERS:");
}
f_conClearScreen( 0, PARAM_ROW);
f_conStrOutXY( "REBUILD PARAMETERS:", LABEL_COLUMN, PARAM_ROW);
bldOutLabel( LABEL_COLUMN + 2, SOURCE_ROW, "Source DB",
gv_szSrcFileName, 0, TRUE);
bldOutLabel( LABEL_COLUMN + 2, SOURCE_DATA_DIR_ROW,
"Src. Data Dir",
(gv_szSrcDataDir [0])
? &gv_szSrcDataDir [0]
: "<NONE>", 0, TRUE);
bldOutLabel( LABEL_COLUMN + 2, DEST_ROW, "Destination DB",
gv_szDestFileName, 0, TRUE);
bldOutLabel( LABEL_COLUMN + 2, DEST_DATA_DIR_ROW,
"Dest. Data Dir",
(gv_szDestDataDir [0])
? &gv_szDestDataDir [0]
: "<NONE>", 0, TRUE);
bldOutLabel( LABEL_COLUMN + 2, DEST_RFL_ROW, "Dest. RFL Dir",
(gv_szDestRflDir [0])
? &gv_szDestRflDir [0]
: "<NONE>", 0, TRUE);
bldOutLabel( LABEL_COLUMN + 2, DICT_ROW, "Dictionary File",
(gv_szDictFileName [0])
? &gv_szDictFileName [0]
: "<NONE>", 0, TRUE);
bldOutLabel( LABEL_COLUMN + 2, CACHE_ROW, "Cache (kb)", NULL,
gv_uiCacheSize, TRUE);
bldOutLabel( LABEL_COLUMN + 2, LOG_FILE_ROW, "Log File",
(gv_szLogFileName [0])
? &gv_szLogFileName [0]
: "<NONE>", 0, TRUE);
bldOutLabel( LABEL_COLUMN, DOING_ROW, "Current Action",
"Startup ", 0L, FALSE);
bldOutLabel( LABEL_COLUMN, DB_SIZE_ROW, "Database Size",
NULL, (FLMUINT)gv_ui64DatabaseSize, FALSE);
bldOutLabel( LABEL_COLUMN, BYTES_DONE_ROW, "Bytes Processed",
NULL, (FLMUINT)gv_ui64BytesDone, FALSE);
bldOutLabel( LABEL_COLUMN, TOTAL_REC_ROW, "Total Records",
NULL, gv_uiTotalRecs, FALSE);
bldOutLabel( LABEL_COLUMN, RECOV_ROW, "Records Recovered",
NULL, gv_uiRecsRecovered, FALSE);
bldOutLabel( LABEL_COLUMN, DICT_RECOV_ROW, "Dict Items Recov",
NULL, gv_uiDictRecsRecovered, FALSE);
if( gv_szDictFileName [0])
{
gv_pszDictPath = &gv_szDictFileName [0];
}
else
{
gv_pszDictPath = NULL;
}
/*
Open the database ONLY to get the createOpts.
Rebuild the exact prefix and other create options.
*/
rc = bldGetCreateOpts( gv_szSrcFileName, &createOpts);
if ((!gv_bShutdown) && (RC_OK( rc)))
{
char * pszDestRflDir;
pszDestRflDir = ((gv_szDestRflDir [0])
? &gv_szDestRflDir [0]
: NULL);
rc = FlmDbRebuild( gv_szSrcFileName, gv_szSrcDataDir,
gv_szDestFileName, gv_szDestDataDir,
pszDestRflDir,
gv_pszDictPath, &createOpts,
&gv_uiTotalRecs,
&gv_uiRecsRecovered,
bldProgFunc, NULL);
bldShowResults( "FlmDbRebuild",
rc, gv_uiTotalRecs, gv_uiRecsRecovered,
gv_uiDictRecsRecovered);
}
Exit:
if( gv_bLoggingEnabled)
{
bldLogFlush();
gv_pLogFile->Release();
gv_pLogFile = NULL;
}
return( bOk);
}
/********************************************************************
Desc: ?
*********************************************************************/
FSTATIC RCODE bldProgFunc(
eStatusType eStatus,
void * Parm1,
void * Parm2,
void * pvAppData
)
{
RCODE rc = FERR_OK;
F_UNREFERENCED_PARM( Parm2);
F_UNREFERENCED_PARM( pvAppData);
if( eStatus == FLM_DB_COPY_STATUS)
{
DB_COPY_INFO * pCopyInfo = (DB_COPY_INFO *)Parm1;
char ucDoing [200];
if( gv_ui64DatabaseSize != pCopyInfo->ui64BytesToCopy)
{
gv_ui64DatabaseSize = pCopyInfo->ui64BytesToCopy;
bldOutNumValue( DB_SIZE_ROW, (FLMUINT)gv_ui64DatabaseSize);
}
gv_ui64BytesDone = pCopyInfo->ui64BytesCopied;
bldOutNumValue( BYTES_DONE_ROW, (FLMUINT)gv_ui64BytesDone);
gv_iLastDoing = -1;
if (pCopyInfo->bNewSrcFile)
{
f_sprintf( (char *)ucDoing, "Saving File %-15s",
(char *)pCopyInfo->szSrcFileName);
ucDoing [25] = 0;
bldOutValue( DOING_ROW, ucDoing);
}
}
else if( eStatus == FLM_REBUILD_STATUS)
{
REBUILD_INFO * Progress = (REBUILD_INFO *)Parm1;
/* First update the display */
if( gv_iLastDoing != Progress->iDoingFlag)
{
gv_ui64DatabaseSize = Progress->ui64DatabaseSize;
bldOutNumValue( DB_SIZE_ROW, (FLMUINT)gv_ui64DatabaseSize);
gv_iLastDoing = Progress->iDoingFlag;
if( gv_iLastDoing == REBUILD_GET_BLK_SIZ)
{
bldOutValue( DOING_ROW, "Determining Block Size ");
}
else if( gv_iLastDoing == REBUILD_RECOVER_DICT)
{
bldOutValue( DOING_ROW, "Recovering Dictionaries ");
}
else
{
bldOutValue( DOING_ROW, "Recovering Data ");
}
}
if( gv_iLastDoing == REBUILD_GET_BLK_SIZ)
{
if( gv_ui64DatabaseSize != Progress->ui64DatabaseSize)
{
gv_ui64DatabaseSize = Progress->ui64DatabaseSize;
bldOutNumValue( DB_SIZE_ROW, (FLMUINT)gv_ui64DatabaseSize);
}
gv_ui64BytesDone = Progress->ui64BytesExamined;
bldOutNumValue( BYTES_DONE_ROW, (FLMUINT)gv_ui64BytesDone);
}
else
{
if( gv_ui64DatabaseSize != Progress->ui64DatabaseSize)
{
gv_ui64DatabaseSize = Progress->ui64DatabaseSize;
bldOutNumValue( DB_SIZE_ROW, (FLMUINT)gv_ui64DatabaseSize);
}
gv_ui64BytesDone = Progress->ui64BytesExamined;
bldOutNumValue( BYTES_DONE_ROW, (FLMUINT)gv_ui64BytesDone);
if( gv_uiTotalRecs != Progress->uiTotRecs)
{
gv_uiTotalRecs = Progress->uiTotRecs;
bldOutNumValue( TOTAL_REC_ROW, gv_uiTotalRecs);
}
if( gv_iLastDoing == REBUILD_RECOVER_DICT)
{
if( gv_uiDictRecsRecovered != Progress->uiRecsRecov)
{
gv_uiDictRecsRecovered = Progress->uiRecsRecov;
bldOutNumValue( DICT_RECOV_ROW, gv_uiDictRecsRecovered);
}
}
else
{
if( gv_uiRecsRecovered != Progress->uiRecsRecov)
{
gv_uiRecsRecovered = Progress->uiRecsRecov;
bldOutNumValue( RECOV_ROW, gv_uiRecsRecovered);
}
}
}
}
else if( eStatus == FLM_PROBLEM_STATUS)
{
CORRUPT_INFO * pCorruptInfo = (CORRUPT_INFO *)Parm1;
bldLogCorruptError( pCorruptInfo);
goto Exit;
}
else if( eStatus == FLM_CHECK_RECORD_STATUS)
{
CHK_RECORD * pChkRec = (CHK_RECORD *)Parm1;
if (pChkRec->pDictRecSet)
{
pChkRec->pDictRecSet->clear();
}
}
if ((f_conHaveKey()) && (f_conGetKey() == FKB_ESCAPE))
{
f_conSetBackFore( FLM_BLACK, FLM_LIGHTGRAY);
f_conClearScreen( 0, 22);
f_conSetBackFore (FLM_RED, FLM_WHITE);
f_conStrOutXY( "ESCAPE key pressed", 0, 22);
rc = bldGetUserInput();
goto Exit;
}
f_yieldCPU();
Exit:
return( rc);
}
