FINLINE void releaseLockFile(
const char * pszBasePath,
FLMBOOL bDelete)
{
#ifndef FLM_UNIX
F_UNREFERENCED_PARM( bDelete);
F_UNREFERENCED_PARM( pszBasePath);
#endif
if( m_pLockFileHdl)
{
// Release the lock file
(void)m_pLockFileHdl->closeFile();
m_pLockFileHdl->Release();
m_pLockFileHdl = NULL;
#ifdef FLM_UNIX
if( bDelete)
{
IF_FileSystem * pFileSystem = f_getFileSysPtr();
char szTmpPath[ F_PATH_MAX_SIZE];
// Delete the lock file
f_strcpy( szTmpPath, pszBasePath);
pFileSystem->pathAppend( szTmpPath, "64.LCK");
pFileSystem->deleteFile( szTmpPath);
}
#endif
}
}
/****************************************************************************
Desc:
*****************************************************************************/
RCODE dlistDefaultDisplayHook(
FTX_WINDOW * pWin,
FLMBOOL bSelected,
FLMUINT uiRow,
FLMUINT uiKey,
void * pvData,
FLMUINT uiDataLen,
F_DynamicList* pDynamicList)
{
eColorType uiBack = FLM_CYAN;
eColorType uiFore = FLM_WHITE;
F_UNREFERENCED_PARM( uiKey);
F_UNREFERENCED_PARM( uiDataLen);
FTXWinSetCursorPos( pWin, 0, uiRow);
FTXWinClearToEOL( pWin);
FTXWinPrintf( pWin, "%s",
(FLMBYTE *)
(pvData ?
pvData :
//the following cast is required by gcc 2.96
(FLMBYTE*)"Unknown"));
if( bSelected && pDynamicList->getShowHorizontalSelector())
{
FTXWinPaintRow( pWin, &uiBack, &uiFore, uiRow);
}
return( NE_FLM_OK);
}
/****************************************************************************
Desc: Page that is displayed when a URL is requested for a page requireing
secure access but the Session security is not enabled. A password
is required.
****************************************************************************/
RCODE F_SessionAccessPage::display(
FLMUINT uiNumParams,
const char ** ppszParams)
{
RCODE rc = FERR_OK;
F_UNREFERENCED_PARM( uiNumParams);
F_UNREFERENCED_PARM( ppszParams);
stdHdr();
fnPrintf( m_pHRequest, HTML_DOCTYPE);
fnPrintf( m_pHRequest, "<html>\n");
fnPrintf( m_pHRequest, "<head>\n");
fnPrintf( m_pHRequest, "<title>Session Access Error Page</title>\n");
fnPrintf( m_pHRequest, "</head>\n");
fnPrintf( m_pHRequest, "<body>\n");
fnPrintf( m_pHRequest, "<STRONG>The page you are attempting to view requires "
"secure access. The session level access has not been enabled."
" To activate session level secure access, you must enter the "
"secure access password.</STRONG>\n");
fnPrintf( m_pHRequest, "</BODY></HTML>\n");
fnEmit();
return( rc);
}
void FLMAPI f_assertMutexNotLocked(
F_MUTEX hMutex)
{
#ifdef FLM_DEBUG
f_assert( ((F_INTERLOCK *)hMutex)->uiThreadId != _threadid);
#else
F_UNREFERENCED_PARM( hMutex);
#endif
}
/****************************************************************************
Desc: Prints the web page for an SCACHE use list
This function is essentially unimplemented because I have yet to see
an SCache page where the use_list value was non-null!!
****************************************************************************/
RCODE F_SCacheUseListPage::display(
FLMUINT uiNumParams,
const char ** ppszParams)
{
F_UNREFERENCED_PARM( uiNumParams);
F_UNREFERENCED_PARM( ppszParams);
RCODE rc = FERR_OK;
stdHdr();
fnPrintf( m_pHRequest,
HTML_DOCTYPE "\n<html>\n <body>\n"
"Congratulations! You've managed to find an SCache block with a valid "
"use list! Too bad we haven't implemented a page to dislay use "
"lists yet...\n </body> </html>");
fnEmit();
return( rc);
}
/****************************************************************************
Desc: Page that is displayed when a URL is requested for a page requireing
secure access but the Global security is not enabled or has expired.
****************************************************************************/
RCODE F_GblAccessPage::display(
FLMUINT uiNumParams,
const char ** ppszParams)
{
RCODE rc = FERR_OK;
F_UNREFERENCED_PARM( uiNumParams);
F_UNREFERENCED_PARM( ppszParams);
stdHdr();
fnPrintf( m_pHRequest, HTML_DOCTYPE);
fnPrintf( m_pHRequest, "<html>\n");
fnPrintf( m_pHRequest, "<head>\n");
fnPrintf( m_pHRequest, "<title>Global Access Error Page</title>\n");
fnPrintf( m_pHRequest, "</head>\n");
fnPrintf( m_pHRequest, "<body>\n");
// We're putting this script here to force the Nav bar to reload. The
// reason for this because of the case where one user disables the secure
// access stuff after a second user has successfully logged in. When the
// second user attempts to load a page requiring secure access he or she
// will get this page. If the nav bar is not reloaded then it will still
// be indicating that the user is logged in and the user will have no idea
// why this page is coming up. If the nav bar is reloaded, it will at
// least give a clue (though not an obvious one) as to what has happened.
fnPrintf( m_pHRequest, "<script>parent.Menu.location.href=\"%s/Nav.htm\" "
"</script>\n", m_pszURLString);
fnPrintf( m_pHRequest, "<STRONG>The page you are attempting to view requires "
"secure access. The secure access either has not been enabled or "
"it has expired. To activate secure access, you must select the "
"\"Access Code\" link in the navigation bar and enter the "
"enabling data provided to you by Novell Inc. You will then need "
"to enter the secure access password.</STRONG>\n");
fnPrintf( m_pHRequest, "</BODY></HTML>\n");
fnEmit();
return( rc);
}
RCODE FTKAPI f_makeErr(
RCODE rc,
const char *, // pszFile,
int, // iLine,
FLMBOOL bAssert)
{
if( rc == NE_FLM_OK)
{
return( NE_FLM_OK);
}
f_assert( rc != NE_FLM_MEM);
#if defined( FLM_DEBUG)
if( bAssert)
{
f_assert( 0);
}
#else
F_UNREFERENCED_PARM( bAssert);
#endif
return( rc);
}
FINLINE FLMBOOL breakCallback(
void * pvData)
{
F_UNREFERENCED_PARM( pvData);
return FALSE;
}
/****************************************************************************
Desc: Prints the web page for the SCacheHashTable
****************************************************************************/
RCODE F_SCacheHashTablePage::display(
FLMUINT uiNumParams,
const char ** ppszParams)
{
RCODE rc = FERR_OK;
FLMBOOL bRefresh;
FLMBOOL bHighlight = TRUE;
FLMUINT uiLoop;
FLMUINT uiHashTableSize;
FLMUINT uiUsedEntries = 0;
char szStart[10];
char szRefresh[] = "&Refresh";
FLMUINT uiStart;
FLMUINT uiNewStart;
char * pszTemp;
#define NUM_ENTRIES 20
char * pszHTLinks[NUM_ENTRIES];
F_UNREFERENCED_PARM( uiNumParams);
F_UNREFERENCED_PARM( ppszParams);
// Check for the refresh parameter
bRefresh = DetectParameter( uiNumParams, ppszParams, "Refresh");
if (!bRefresh)
{
szRefresh[0]='\0'; // Effectively turns szRefresh into a null string
}
// Get the starting entry number...
if (RC_BAD( rc = ExtractParameter( uiNumParams, ppszParams,
"Start", sizeof( szStart),
szStart)))
{
flmAssert( 0);
goto Exit;
}
uiStart = f_atoud( szStart);
// Allocate space for the hyperlink text
for (uiLoop = 0; uiLoop < NUM_ENTRIES; uiLoop++)
{
if( RC_BAD( rc = f_alloc( 250, &pszHTLinks[ uiLoop])))
{
printErrorPage( rc, TRUE, (char *)"Failed to allocate temporary buffer");
goto Exit;
}
pszHTLinks[uiLoop][0] = '\0';
}
if( RC_BAD( rc = f_alloc( 250, &pszTemp)))
{
printErrorPage( rc, TRUE, (char *)"Failed to allocate temporary buffer");
goto Exit;
}
// Lock the database
f_mutexLock( gv_FlmSysData.hShareMutex);
// Get the number of entries in the hash table
uiHashTableSize = gv_FlmSysData.SCacheMgr.uiHashTblSize;
// May need to modify starting number if it's out of range...
if ((uiStart + NUM_ENTRIES) >= uiHashTableSize)
{
uiStart = uiHashTableSize - NUM_ENTRIES;
}
// Loop through the entire table counting the number of entries in use
// If the entry is one of the one's we're going to display, store the
// appropriate text in pszHTLinks
for (uiLoop = 0; uiLoop < uiHashTableSize; uiLoop++)
{
if (gv_FlmSysData.SCacheMgr.ppHashTbl[uiLoop])
{
uiUsedEntries++;
}
if ( (uiLoop >= uiStart) &&
(uiLoop < (uiStart + NUM_ENTRIES)) )
{
// This is one of the entries that we will display
if (gv_FlmSysData.SCacheMgr.ppHashTbl[uiLoop])
{
flmBuildSCacheBlockString( pszHTLinks[uiLoop - uiStart],
gv_FlmSysData.SCacheMgr.ppHashTbl[uiLoop]);
}
}
}
// Unlock the database
f_mutexUnlock( gv_FlmSysData.hShareMutex);
// Begin rendering the page...
stdHdr();
printStyle();
fnPrintf( m_pHRequest, HTML_DOCTYPE "<html>\n");
// Determine if we are being requested to refresh this page or not.
if (bRefresh)
{
fnPrintf( m_pHRequest,
"<HEAD>"
"<META http-equiv=\"refresh\" content=\"5; url=%s/SCacheHashTable?Start=%lu%s\">"
"<TITLE>Database iMonitor - SCache Hash Table</TITLE>\n", m_pszURLString, uiStart, szRefresh);
}
else
{
fnPrintf( m_pHRequest, "<HEAD>\n");
}
// If we are not to refresh this page, then don't include the
// refresh meta command
if (!bRefresh)
{
f_sprintf( (char *)pszTemp,
"<A HREF=%s/SCacheHashTable?Start=%lu&Refresh>Start Auto-refresh (5 sec.)</A>",
m_pszURLString, uiStart);
}
else
{
f_sprintf( (char *)pszTemp,
"<A HREF=%s/SCacheHashTable?Start=%lu>Stop Auto-refresh</A>",
m_pszURLString, uiStart);
}
// Print out a formal header and the refresh option.
printTableStart("SCache Hash Table", 4);
printTableRowStart();
printColumnHeading( "", JUSTIFY_LEFT, FLM_IMON_COLOR_PUTTY_1, 4, 1, FALSE);
fnPrintf( m_pHRequest,
"<A HREF=%s/SCacheHashTable?Start=%lu%s>Refresh</A>, %s\n",
m_pszURLString, uiStart, szRefresh, pszTemp);
printColumnHeadingClose();
printTableRowEnd();
printTableRowStart( (bHighlight = !bHighlight));
fnPrintf( m_pHRequest, "<TD>Table Size: %lu </TD>\n", uiHashTableSize);
printTableRowEnd();
printTableRowStart( (bHighlight = !bHighlight));
fnPrintf( m_pHRequest, "<TD>Entries Used: %lu (%lu%%) </TD>\n", uiUsedEntries,
((uiUsedEntries * 100) / uiHashTableSize) );
printTableRowEnd();
// The rest of the table is going to be a single row with two columns:
// one for the list of hash buckets and the other for everything else
printTableRowStart( FALSE);
fnPrintf( m_pHRequest, " <TD>\n");
// Print out the hash buckets
for (uiLoop = 0; uiLoop < NUM_ENTRIES; uiLoop++)
{
if (pszHTLinks[uiLoop][0] != '\0')
{
fnPrintf( m_pHRequest, "<A HREF=%s%s>%lu</A> <br>\n",
pszHTLinks[uiLoop], szRefresh, uiStart+uiLoop);
}
else
{
fnPrintf( m_pHRequest, "%lu<br>\n", uiStart+uiLoop);
}
}
fnPrintf( m_pHRequest, "</ul>\n</TD>\n<TD>\n");
// Print out the other stuff...
uiNewStart = (uiStart > 100)?(uiStart - 100):0;
fnPrintf( m_pHRequest, "<A HREF=%s/SCacheHashTable?Start=%lu%s>Previous 100</A> <BR>\n",
m_pszURLString, uiNewStart, szRefresh);
uiNewStart = (uiStart > 10)?(uiStart - 10):0;
fnPrintf( m_pHRequest, "<A HREF=%s/SCacheHashTable?Start=%lu%s>Previous 10</A> <BR>\n",
m_pszURLString, uiNewStart, szRefresh);
fnPrintf( m_pHRequest, "<BR>\n");
uiNewStart = (uiStart + 10);
if (uiNewStart >= (uiHashTableSize - NUM_ENTRIES))
{
uiNewStart = (uiHashTableSize - NUM_ENTRIES);
}
fnPrintf( m_pHRequest, "<A HREF=%s/SCacheHashTable?Start=%lu%s>Next 10</A> <BR>\n",
m_pszURLString, uiNewStart, szRefresh);
uiNewStart = (uiStart + 100);
if (uiNewStart >= (uiHashTableSize - NUM_ENTRIES))
{
uiNewStart = (uiHashTableSize - NUM_ENTRIES);
}
fnPrintf( m_pHRequest, "<A HREF=%s/SCacheHashTable?Start=%lu%s>Next 100</A> <BR>\n"
"<form type=\"submit\" method=\"get\" action=\"/coredb/SCacheHashTable\">\n"
"<BR> Jump to specific bucket:<BR> \n"
"<INPUT type=\"text\" size=\"10\" maxlength=\"10\" name=\"Start\"></INPUT> <BR>\n",
m_pszURLString, uiNewStart, szRefresh);
printButton( "Jump", BT_Submit);
// We use a hidden field to pass the refresh parameter back the the server
if (bRefresh)
{
fnPrintf( m_pHRequest, "<INPUT type=\"hidden\" name=\"Refresh\"></INPUT>\n");
}
fnPrintf( m_pHRequest, "</form>\n</TD>\n");
printTableRowEnd();
printTableEnd();
printDocEnd();
fnEmit();
Exit:
// Free the space for the hyperlink text
for (uiLoop = 0; uiLoop < NUM_ENTRIES; uiLoop++)
{
f_free( &pszHTLinks[uiLoop]);
}
f_free( &pszTemp);
return( rc);
}
/****************************************************************************
Desc: This procedure generates the HTML page to display
the contents of the FFile structure
****************************************************************************/
void F_FFilePage::write_data(
FFILE * pFile,
void * pvFFileAddress,
DATASTRUCT * pDataStruct)
{
char szFormattedTime[13];
char szTemp[100];
char szAddress[20];
char szFFileAddress[20];
FLMBOOL bHighlight = FALSE;
F_UNREFERENCED_PARM( fnPrintf);
if (pFile == NULL)
{
flmAssert(0);
return;
}
else
{
printAddress( pvFFileAddress, szFFileAddress);
// pNext
if ( pFile->pNext)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pNext?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pNext",
"FFILE *",
(void *)pFile,
(void *)&pFile->pNext,
(void *)pFile->pNext,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pPrev - previous file in hash bucket.
if (pFile->pPrev)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pPrev?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pPrev",
"FFILE *",
(void *)pFile,
(void *)&pFile->pPrev,
(void *)pFile->pPrev,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiZeroUseCountTime - Time Use Count went to zero
FormatTime(pFile->uiZeroUseCountTime, szFormattedTime);
printHTMLString(
"uiZeroUseCountTime",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiZeroUseCountTime,
(char *)szFormattedTime,
(bHighlight = ~bHighlight));
// uiInternalUseCount - Internal Use Count
printHTMLUint(
"uiInternalUseCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiInternalUseCount,
pFile->uiInternalUseCount,
(bHighlight = ~bHighlight));
// uiUseCount - Current Use Count
printHTMLUint(
"uiUseCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiUseCount,
pFile->uiUseCount,
(bHighlight = ~bHighlight));
// pFirstDb
if (pFile->pFirstDb)
{
char szFDBAddr[20];
printAddress( pFile->pFirstDb, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf( (char *)szTemp,
"%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pFirstDb",
"FDB *",
(void *)pFile,
(void *)&pFile->pFirstDb,
(void *)pFile->pFirstDb,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pszDbPath - Database File Name
printHTMLString(
"pszDbPath",
"FLMBYTE *",
(void *)pFile,
(void *)&pFile->pszDbPath,
(char *)(pFile->pszDbPath ? (char *)pFile->pszDbPath : "Null"),
(bHighlight = ~bHighlight));
// pszDataDir
printHTMLString(
"pszDataDir",
"FLMBYTE *",
(void *)pFile,
(void *)&pFile->pszDataDir,
(char *)(pFile->pszDataDir ? (char *)pFile->pszDataDir : "Null"),
(bHighlight = ~bHighlight));
// pNextNUFile - Next Not Used File
if (pFile->pNextNUFile)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pNextNUFile?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pNextNUFile",
"FFILE *",
(void *)pFile,
(void *)&pFile->pNextNUFile,
(void *)pFile->pNextNUFile,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pPrevNUFile - Previous Not Used File
if (pFile->pPrevNUFile)
{
f_sprintf( (char *)szTemp,
"%s/FFile?From=FFile?Link=pPrevNUFile?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pPrevNUFile",
"FFILE *",
(void *)pFile,
(void *)&pFile->pPrevNUFile,
(void *)pFile->pPrevNUFile,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pSCacheList - Shared Cache Blocks
if (pFile->pSCacheList)
{
f_sprintf( (char *)szTemp,
"%s/SCacheBlock?"
"BlockAddress=%ld&File=%s&LowTransID=%ld&HighTransID=%ld",
m_pszURLString,
pDataStruct->SCacheBlkAddress,
szFFileAddress,
pDataStruct->SCacheLowTransID,
pDataStruct->SCacheHighTransID);
}
printHTMLLink(
"pSCacheList",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pSCacheList,
(void *)pFile->pSCacheList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pPendingWriteList
if (pFile->pPendingWriteList)
{
f_sprintf( (char *)szTemp,
"%s/SCacheBlock?"
"BlockAddress=%ld&File=%s&LowTransID=%ld&HighTransID=%ld",
m_pszURLString,
pDataStruct->PendingWriteBlkAddress,
szFFileAddress,
pDataStruct->PendingWriteLowTransID,
pDataStruct->PendingWriteHighTransID);
}
printHTMLLink(
"pPendingWriteList",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pPendingWriteList,
(void *)pFile->pPendingWriteList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLastDirtyBlk
if (pFile->pLastDirtyBlk)
{
f_sprintf( (char *)szTemp,
"%s/SCacheBlock?"
"BlockAddress=%ld&File=%s&LowTransID=%ld&HighTransID=%ld",
m_pszURLString,
pDataStruct->LastDirtyBlkAddress,
szFFileAddress,
pDataStruct->LastDirtyLowTransID,
pDataStruct->LastDirtyHighTransID);
}
printHTMLLink(
"pLastDirtyBlk",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pLastDirtyBlk,
(void *)pFile->pLastDirtyBlk,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiDirtyCacheCount
printHTMLUint(
"uiDirtyCacheCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiDirtyCacheCount,
pFile->uiDirtyCacheCount,
(bHighlight = ~bHighlight));
// uiLogCacheCount
printHTMLUint(
"uiLogCacheCount",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiLogCacheCount,
pFile->uiLogCacheCount,
(bHighlight = ~bHighlight));
// pFirstRecord - First Record Cache Block
// **Do we need to rework this by passing in the Container, Drn, pFile & LowTransId? ** //
if (pFile->pFirstRecord)
{
f_sprintf( (char *)szTemp,
"%s/RCache?Container=%lu?DRN=%lu?File=%s?Version=%lu",
m_pszURLString,
pDataStruct->FirstRecordContainer,
pDataStruct->FirstRecordDrn,
szFFileAddress,
pDataStruct->FirstRecordLowTransId);
}
printHTMLLink(
"pFirstRecord",
"RCACHE_p",
(void *)pFile,
(void *)&pFile->pFirstRecord,
(void *)pFile->pFirstRecord,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLastRecord - Last Record Cache Block
if (pFile->pLastRecord)
{
f_sprintf( (char *)szTemp,
"%s/RCache?Container=%lu?DRN=%lu?File=%s?Version=%lu",
m_pszURLString,
pDataStruct->LastRecordContainer,
pDataStruct->LastRecordDrn,
szFFileAddress,
pDataStruct->LastRecordLowTransId);
}
printHTMLLink(
"pLastRecord",
"RCACHE_p",
(void *)pFile,
(void *)&pFile->pLastRecord,
(void *)pFile->pLastRecord,
(char *)szTemp,
(bHighlight = ~bHighlight));
// ppBlocksDone - List of blocks to be written to the Rollback
if (pFile->ppBlocksDone)
{
f_sprintf( (char *)szTemp,
"%s/SCache?From=FFile?Link=ppBlocksDone?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"ppBlocksDone",
"SCACHE **",
(void *)pFile,
(void *)&pFile->ppBlocksDone,
(void *)pFile->ppBlocksDone,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiBlocksDoneArraySize
printHTMLUint(
"uiBlocksDoneArraySize",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiBlocksDoneArraySize,
pFile->uiBlocksDoneArraySize,
(bHighlight = ~bHighlight));
// uiBlocksDone - Number of Blocks in Blocks Done Array
printHTMLUint(
"uiBlocksDone",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiBlocksDone,
pFile->uiBlocksDone,
(bHighlight = ~bHighlight));
// pTransLogList - Shared Cache Log List
if (pFile->pTransLogList != NULL)
{
f_sprintf( (char *)szTemp,
"%s/SCache?From=FFile?Link=pTransLogList?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pTransLogList",
"SCACHE *",
(void *)pFile,
(void *)&pFile->pTransLogList,
(void *)pFile->pTransLogList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pOpenNotifies - Open Notifies Threads
if (pFile->pOpenNotifies != NULL)
{
f_sprintf( (char *)szTemp,
"%s/FNOTIFY?From=FFile?Link=pOpenNotifies?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pOpenNotifies",
"FNOTIFY *",
(void *)pFile,
(void *)&pFile->pOpenNotifies,
(void *)pFile->pOpenNotifies,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pCloseNotifies
if (pFile->pCloseNotifies != NULL)
{
f_sprintf( (char *)szTemp,
"%s/FNOTIFY?From=FFile?Link=pCloseNotifies?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pCloseNotifies",
"FNOTIFY *",
(void *)pFile,
(void *)&pFile->pCloseNotifies,
(void *)pFile->pCloseNotifies,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pDictList - Dictionaries List
if (pFile->pDictList != NULL)
{
f_sprintf( (char *)szTemp,
"%s/FDICT?From=FFile?Link=pDictList?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pDictList",
"FDICT *",
(void *)pFile,
(void *)&pFile->pDictList,
(void *)pFile->pDictList,
(char *)szTemp,
(bHighlight = ~bHighlight));
// krefPool - Kref pool
printAddress( &pFile->krefPool, szAddress);
printHTMLString(
"krefPool",
"POOL",
(void *)pFile,
(void *)&pFile->krefPool,
(char *)szAddress,
(bHighlight = ~bHighlight));
// FileHdr - File Header
f_sprintf( (char *)szTemp,
"%s/FILE_HDR?From=FFile?Link=FileHdr?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
printHTMLLink(
"FileHdr",
"FILE_HDR",
(void *)pFile,
(void *)&pFile->FileHdr,
(void *)&pFile->FileHdr,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiMaxFileSize - Maximum File Size
printHTMLUint(
"uiMaxFileSize",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiMaxFileSize,
pFile->uiMaxFileSize,
(bHighlight = ~bHighlight));
// uiFileExtendSize - File Extend Size
printHTMLUint(
"uiFileExtendSize",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFileExtendSize,
pFile->uiFileExtendSize,
(bHighlight = ~bHighlight));
// uiUpdateTransID - Update Transaction Id
printHTMLUint(
"uiUpdateTransID",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiUpdateTransID,
pFile->uiUpdateTransID,
(bHighlight = ~bHighlight));
// pRfl - Roll Forward Log Object
if (pFile->pRfl)
{
f_sprintf( (char *)szTemp,
"%s/Rfl?From=FFile?Link=pRfl?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pRfl",
"F_Rfl *",
(void *)pFile,
(void *)&pFile->pRfl,
(void *)pFile->pRfl,
(char *)szTemp,
(bHighlight = ~bHighlight));
// ucLastCommittedLogHdr - Last Committed Log Header
f_sprintf( (char *)szTemp,
"%s/LogHdr?From=FFile?"
"Link=ucLastCommittedLogHdr?"
"Address=%s?Bucket=%ld",
m_pszURLString,
szFFileAddress, pFile->uiBucket);
printHTMLLink(
"ucLastCommittedLogHdr",
"FLMBYTE",
(void *)pFile,
(void *)&pFile->ucLastCommittedLogHdr[0],
(void *)&pFile->ucLastCommittedLogHdr[0],
(char *)szTemp,
(bHighlight = ~bHighlight));
// ucCheckpointLogHdr - Checkpoint Log Header
f_sprintf( (char *)szTemp,
"%s/LogHdr?From=FFile?"
"Link=ucCheckpointLogHdr?"
"Address=%s?Bucket=%ld",
m_pszURLString,
szFFileAddress, pFile->uiBucket);
printHTMLLink(
"ucCheckpointLogHdr",
"FLMBYTE",
(void *)pFile,
(void *)&pFile->ucCheckpointLogHdr[0],
(void *)&pFile->ucCheckpointLogHdr[0],
(char *)szTemp,
(bHighlight = ~bHighlight));
// ucUncommittedLogHdr - Uncommitted Log Header
f_sprintf( (char *)szTemp,
"%s/LogHdr?From=FFile?Link=ucUncommittedLogHdr?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress, (unsigned long)pFile->uiBucket);
printHTMLLink(
"ucUncommittedLogHdr",
"FLMBYTE",
(void *)pFile,
(void *)&pFile->ucUncommittedLogHdr[0],
(void *)&pFile->ucUncommittedLogHdr[0],
(char *)szTemp,
(bHighlight = ~bHighlight));
// pBufferMgr
f_sprintf( (char *)szTemp,
"%s/F_IOBufferMgr?From=FFile?"
"Link=pBufferMgr?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
printHTMLLink(
"pBufferMgr",
"F_IOBufferMgr *",
(void *)pFile,
(void *)&pFile->pBufferMgr,
(void *)pFile->pBufferMgr,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pCurrLogBuffer
f_sprintf( (char *)szTemp,
"%s/F_IOBuffer?From=FFile?"
"Link=pCurrLogBuffer?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
printHTMLLink(
"pCurrLogBuffer",
"F_IOBuffer *",
(void *)pFile,
(void *)&pFile->pCurrLogBuffer,
(void *)pFile->pCurrLogBuffer,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiCurrLogWriteOffset
printHTMLUint(
"uiCurrLogWriteOffset",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiCurrLogWriteOffset,
pFile->uiCurrLogWriteOffset,
(bHighlight = ~bHighlight));
// uiCurrLogBlkAddr
printHTMLUint(
"uiCurrLogBlkAddr",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiCurrLogBlkAddr,
pFile->uiCurrLogBlkAddr,
(bHighlight = ~bHighlight));
// pFileLockObj - File Locking Object
if (pFile->pFileLockObj)
{
f_sprintf( (char *)szTemp,
"%s/ServerLockObject?From=FFile?"
"Link=pFileLockObj?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pFileLockObj",
"ServerLockObject_p",
(void *)pFile,
(void *)&pFile->pFileLockObj,
(void *)pFile->pFileLockObj,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pWriteLockObj
if (pFile->pWriteLockObj)
{
f_sprintf( (char *)szTemp,
"%s/ServerLockObject?From=FFile?"
"Link=pWriteLockObj?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pWriteLockObj",
"ServerLockObject_p",
(void *)pFile,
(void *)&pFile->pWriteLockObj,
(void *)pFile->pWriteLockObj,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLockFileHdl - File Lock Handle (3.x Db)
if (pFile->pLockFileHdl)
{
f_sprintf( (char *)szTemp,
"%s/F_FileHdl?From=FFile?"
"Link=pLockFileHdl?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pLockFileHdl",
"F_FileHdl_p",
(void *)pFile,
(void *)&pFile->pLockFileHdl,
(void *)pFile->pLockFileHdl,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLockNotifies - Notifies List
if (pFile->pLockNotifies)
{
f_sprintf( (char *)szTemp,
"%s/FNOTIFY?From=FFile?"
"Link=pLockNotifies?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pLockNotifies",
"FNOTIFY *",
(void *)pFile,
(void *)&pFile->pLockNotifies,
(void *)pFile->pLockNotifies,
(char *)szTemp,
(bHighlight = ~bHighlight));
// bBeingLocked - File being locked
printHTMLString(
"bBeingLocked",
"FLMBOOL",
(void *)pFile,
(void *)&pFile->bBeingLocked,
(char *)(pFile->bBeingLocked ? "Yes" : "No"),
(bHighlight = ~bHighlight));
// pFirstReadTrans - First Read Transaction
if (pFile->pFirstReadTrans)
{
char szFDBAddr[20];
printAddress( pFile->pFirstReadTrans, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf( (char *)szTemp,
"%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pFirstReadTrans",
"FDB *",
(void *)pFile,
(void *)&pFile->pFirstReadTrans,
(void *)pFile->pFirstReadTrans,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pLastReadTrans - Last Read Transaction
if (pFile->pLastReadTrans)
{
char szFDBAddr[20];
printAddress( pFile->pLastReadTrans, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf(
(char *)szTemp, "%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pLastReadTrans",
"FDB *",
(void *)pFile,
(void *)&pFile->pLastReadTrans,
(void *)pFile->pLastReadTrans,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pFirstKilledTrans - First Killed Transaction
if (pFile->pFirstKilledTrans)
{
char szFDBAddr[20];
printAddress( pFile->pFirstKilledTrans, szAddress);
f_sprintf( szFDBAddr, "%s", szAddress);
f_sprintf(
(char *)szTemp, "%s/FDB?FFileAddress=%s?Bucket=%lu?FDBAddress=%s",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket, szFDBAddr);
}
printHTMLLink(
"pFirstKilledTrans",
"FDB *",
(void *)pFile,
(void *)&pFile->pFirstKilledTrans,
(void *)pFile->pFirstKilledTrans,
(char *)szTemp,
(bHighlight = ~bHighlight));
// uiFirstLogBlkAddress
printHTMLUint(
"uiFirstLogBlkAddress",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFirstLogBlkAddress,
pFile->uiFirstLogBlkAddress,
(bHighlight = ~bHighlight));
// uiFirstLogCPBlkAddress - First Log Checkpoint Block Address
printHTMLUint(
"uiFirstLogCPBlkAddress",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFirstLogCPBlkAddress,
pFile->uiFirstLogCPBlkAddress,
(bHighlight = ~bHighlight));
// uiLastCheckpointTime - Last Checkpoint Time
FormatTime( pFile->uiLastCheckpointTime, szFormattedTime);
printHTMLString(
"uiLastCheckpointTime",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiLastCheckpointTime,
(char *)szFormattedTime,
(bHighlight = ~bHighlight));
// pCPThrd
if (pFile->pCPThrd)
{
f_sprintf( (char *)szTemp,
"%s/F_Thread?From=FFile?"
"Link=pCPThrd?"
"Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pCPThrd",
"F_Thread *",
(void *)pFile,
(void *)&pFile->pCPThrd,
(void *)pFile->pCPThrd,
(char *)szTemp,
(bHighlight = ~bHighlight));
// pCPInfo - Checkpoint Info Buffer
if (pFile->pCPInfo)
{
f_sprintf( (char *)szTemp,
"%s/CP_INFO?From=FFile?Link=pCPInfo?Address=%s?Bucket=%lu",
m_pszURLString,
szFFileAddress,
(unsigned long)pFile->uiBucket);
}
printHTMLLink(
"pCPInfo",
"CP_INFO_p",
(void *)pFile,
(void *)&pFile->pCPInfo,
(void *)pFile->pCPInfo,
(char *)szTemp,
(bHighlight = ~bHighlight));
// CheckpointRc - Last Checkpoint Return Code
printHTMLUint(
"CheckpointRc",
"FLMUINT",
(void *)pFile,
(void *)&pFile->CheckpointRc,
pFile->CheckpointRc,
(bHighlight = ~bHighlight));
// uiBucket - Hash Table Bucket
printHTMLUint(
"uiBucket",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiBucket,
pFile->uiBucket,
(bHighlight = ~bHighlight));
// uiFlags - Flags
if (pFile->uiFlags)
{
FLMBOOL bTest = FALSE;
char * pTemp = (char *)szTemp;
f_sprintf( (char *)szTemp, "%08X<br>", (unsigned)pFile->uiFlags);
pTemp += 12;
if (pFile->uiFlags & DBF_BEING_OPENED)
{
f_sprintf(pTemp, "Being Opened");
pTemp += f_strlen("Being Opened");
bTest=TRUE;
}
if (pFile->uiFlags & DBF_IN_NU_LIST)
{
if (bTest)
{
f_sprintf(pTemp, "<br>");
pTemp += f_strlen("<br>");
}
f_sprintf(pTemp, "In Not Used List");
pTemp += f_strlen("In Not Used List");
bTest = TRUE;
}
if (pFile->uiFlags & DBF_BEING_CLOSED)
{
if (bTest)
{
f_sprintf(pTemp, "<br>");
pTemp += f_strlen("<br>");
}
f_sprintf(pTemp, "Being Closed");
pTemp += f_strlen("Being Closed");
}
}
else
{
f_sprintf( (char *)szTemp, "%08X<br>Normal", (unsigned)pFile->uiFlags);
}
printHTMLString(
"uiFlags",
"FLMUINT",
(void *)pFile,
(void *)&pFile->uiFlags,
(char *)szTemp,
(bHighlight = ~bHighlight));
// bBackupActive - Backup Active
printHTMLString(
"bBackupActive",
"FLMBOOL",
(void *)pFile,
(void *)&pFile->bBackupActive,
(char *)(pFile->bBackupActive ? "Yes" : "No"),
(bHighlight = ~bHighlight));
printTableEnd();
}
}
FSTATIC RCODE ixDisplayHook(
FTX_WINDOW * pWin,
FLMBOOL bSelected,
FLMUINT uiRow,
FLMUINT uiKey,
void * pvData,
FLMUINT uiDataLen,
F_DynamicList* pDynamicList)
{
eColorType uiBack = FLM_CYAN;
eColorType uiFore = FLM_WHITE;
IX_DISPLAY_INFO * pDispInfo = (IX_DISPLAY_INFO *)pvData;
char szTmpBuf [100];
const char * pszState;
FLMUINT uiGMT;
F_UNREFERENCED_PARM( uiKey);
F_UNREFERENCED_PARM( uiDataLen);
flmAssert( uiDataLen == sizeof( IX_DISPLAY_INFO));
f_timeGetSeconds( &uiGMT );
if( pDispInfo->IndexStatus.eState == XFLM_INDEX_SUSPENDED)
{
pszState = "Susp";
}
else if( pDispInfo->IndexStatus.eState == XFLM_INDEX_ONLINE)
{
pszState = "Onln";
}
else
{
pszState = "Offln";
}
pDispInfo->szName [15] = 0;
if( pDispInfo->IndexStatus.ui64LastDocumentIndexed != (FLMUINT64)~0)
{
f_sprintf( szTmpBuf, "%5u %-15s %-5s %-10u %-10u %-10u %-10u %-10u",
(unsigned)uiKey, pDispInfo->szName, pszState,
(unsigned)pDispInfo->IndexStatus.ui64LastDocumentIndexed,
(unsigned)pDispInfo->uiIndexingRate,
(unsigned)pDispInfo->IndexStatus.ui64KeysProcessed,
(unsigned)pDispInfo->IndexStatus.ui64DocumentsProcessed,
(unsigned)(pDispInfo->bShowTime
? pDispInfo->IndexStatus.ui32StartTime
? uiGMT - pDispInfo->IndexStatus.ui32StartTime
: 0
: pDispInfo->IndexStatus.ui64Transactions));
}
else
{
f_sprintf( szTmpBuf,
"%5u %-15s %-5s %-10u",
(unsigned)uiKey, pDispInfo->szName, pszState,
(unsigned)(pDispInfo->bShowTime
? pDispInfo->IndexStatus.ui32StartTime
? uiGMT - pDispInfo->IndexStatus.ui32StartTime
: 0
: pDispInfo->IndexStatus.ui64Transactions));
}
FTXWinSetCursorPos( pWin, 0, uiRow);
FTXWinClearToEOL( pWin);
FTXWinPrintf( pWin, "%s", szTmpBuf);
if( bSelected && pDynamicList->getShowHorizontalSelector())
{
FTXWinPaintRow( pWin, &uiBack, &uiFore, uiRow);
}
return( NE_XFLM_OK);
}
/****************************************************************************
Name: UIMain
****************************************************************************/
void UIMain( void * pData)
{
F_Db * pDb = NULL;
FTX_SCREEN * pScreen = NULL;
FTX_WINDOW * pTitleWin = NULL;
F_DomEditor * pDomEditor = NULL;
char szTitle[ 80];
FLMUINT uiDummy;
char szDbPath [F_PATH_MAX_SIZE];
FLMUINT Cols;
FLMUINT Rows;
RCODE rc;
int iResCode = 0;
F_UNREFERENCED_PARM( pData);
if( RC_BAD( dbSystem.init()))
{
iResCode = -1;
goto Exit;
}
f_sprintf( szTitle,
"DOMEdit for XFLAIM [DB=%s/BUILD=%s]",
XFLM_CURRENT_VER_STR, __DATE__);
if( RC_BAD( FTXInit( szTitle, 80, 50, FLM_BLUE, FLM_WHITE, NULL, NULL)))
{
iResCode = 1;
goto Exit;
}
FTXSetShutdownFlag( gv_pFtxInfo, &gv_bShutdown);
if( FTXScreenInit( gv_pFtxInfo, szTitle, &pScreen) != FTXRC_SUCCESS)
{
iResCode = 1;
goto Exit;
}
if( FTXWinInit( pScreen, 0, 1, &pTitleWin) != FTXRC_SUCCESS)
{
iResCode = 1;
goto Exit;
}
if( FTXWinPaintBackground( pTitleWin, FLM_RED) != FTXRC_SUCCESS)
{
iResCode = 1;
goto Exit;
}
if( FTXWinPrintStr( pTitleWin, szTitle) != FTXRC_SUCCESS)
{
iResCode = 1;
goto Exit;
}
FTXWinSetCursorType( pTitleWin, FLM_CURSOR_INVISIBLE);
if( FTXWinOpen( pTitleWin) != FTXRC_SUCCESS)
{
iResCode = 1;
goto Exit;
}
if( RC_BAD( pThreadMgr->createThread( &gv_pBackgroundThrd,
_domEditBackgroundThread, "domedit_refresh")))
{
iResCode = 1;
goto Exit;
}
/*
Check expiration date
*/
if( RC_BAD( rc = domEditVerifyRun()))
{
FTXDisplayMessage( pScreen, FLM_RED, FLM_WHITE,
"This Utility Has Expired",
"NE_XFLM_ILLEGAL_OP", &uiDummy);
f_sleep( 5000);
iResCode = 1;
goto Exit;
}
/*
Open the database
*/
if( gv_szDbPath[ 0])
{
if( RC_BAD( rc = dbSystem.dbOpen( gv_szDbPath, NULL, gv_szRflDir,
(IF_Db **)&pDb, gv_szPassword, gv_bAllowLimited)))
{
char szErr [20];
f_sprintf( szErr, "Error=0x%04X", (unsigned)rc);
FTXDisplayMessage( pScreen, FLM_RED, FLM_WHITE,
"Unable to open the database", szErr, &uiDummy);
iResCode = 1;
goto Exit;
}
}
else
{
if( RC_BAD( rc = dbSystem.dbOpen( szDbPath, NULL, gv_szRflDir,
(IF_Db **)&pDb, gv_szPassword, gv_bAllowLimited)))
{
char szErr [20];
f_sprintf( szErr, "Error=0x%04X", (unsigned)rc);
FTXDisplayMessage( pScreen, FLM_RED, FLM_WHITE,
"Unable to open the database", szErr, &uiDummy);
iResCode = 1;
goto Exit;
}
else
{
FTXWinClear( pTitleWin);
if( FTXWinPrintf( pTitleWin, "%s (Direct)", szTitle) != FTXRC_SUCCESS)
{
iResCode = 1;
goto Exit;
}
}
}
if( (pDomEditor = f_new F_DomEditor) == NULL)
{
iResCode = 1;
goto Exit;
}
if( RC_BAD( pDomEditor->Setup( pScreen)))
{
iResCode = 1;
goto Exit;
}
pDomEditor->setSource( pDb, XFLM_DATA_COLLECTION);
pDomEditor->setShutdown( &gv_bShutdown);
/*
Fire up the editor
*/
FTXScreenGetSize( pScreen, &Cols, &Rows);
pDomEditor->interactiveEdit( 0, 1, Cols - 1, Rows - 1);
Exit:
if( pDomEditor)
{
pDomEditor->Release();
pDomEditor = NULL;
}
gv_bShutdown = TRUE;
if (pDb)
{
pDb->Release();
}
if( gv_pBackgroundThread)
{
gv_pBackgroundThrd->Release();
}
if( pThreadMgr)
{
pThreadMgr->Release();
}
dbSystem.exit();
}
/********************************************************************
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);
}
