able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/troubleshoot/control/cachegen.cpp

874 lines
16 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//
// MODULE: CACHEGEN.CPP
//
// PURPOSE: Cache File Generator and Reader for BN Networks
//
// PROJECT: Generic Troubleshooter DLL for Microsoft AnswerPoint
//
// COMPANY: Saltmine Creative, Inc. (206)-284-7511 support@saltmine.com
//
// AUTHOR: Roman Mach
//
// ORIGINAL DATE: 8/7/97
//
// NOTES:
// 1.
//
// Version Date By Comments
//--------------------------------------------------------------------
// V0.2 8/7/97 RM Local Version for Memphis
// V0.3 04/09/98 JM/OK+ Local Version for NT5
//
#include "stdafx.h"
#include <afxwin.h>
#include <afxtempl.h>
#include "apgts.h"
#include "bnts.h"
#include "cachegen.h"
#include "BackupInfo.h"
#include "apgtsinf.h"
#include "ChmRead.h"
int nodecomp(const void *elem1, const void *elem2);
//
//
GTSCacheGenerator::GTSCacheGenerator(BOOL bScanAll, const char *szLogFile, const char *szBNTSLogFile)
{
m_fp = NULL;
m_bScanAll = bScanAll;
m_szBNTSLogFile = szBNTSLogFile;
if (szLogFile != NULL)
m_fp = fopen(szLogFile, "w");
m_nCount = 0;
m_nItemCount = 0;
m_headposition = 0;
m_filedata = NULL;
m_netstartoffset = 0;
m_nodeorder = NULL;
}
//
//
GTSCacheGenerator::~GTSCacheGenerator()
{
if (m_fp)
fclose(m_fp);
if (m_filedata)
free(m_filedata);
if (m_nodeorder)
free(m_nodeorder);
}
bool GTSCacheGenerator::TcharToChar(char szOut[], LPCTSTR szIn, int &OutLen)
{
int x = 0;
while(NULL != szIn[x] && x < OutLen)
{
szOut[x] = (char) szIn[x];
x++;
}
if (x < OutLen)
szOut[x] = NULL;
return x < OutLen;
}
//
//
/*
void GTSCacheGenerator::LogOut(TCHAR *szcFormat, ...)
{
va_list ptr;
if (!m_fp)
return;
if (!szcFormat)
return;
va_start(ptr, szcFormat);
vfprintf(m_fp, szcFormat, ptr);
va_end(ptr);
}
*/
#ifdef _DEBUG
#define LogOut ::AfxTrace
//#define LogOut 1 ? (void)0 : ::AfxTrace
#else
#define LogOut 1 ? (void)0 : ::AfxTrace
#endif
//
//
int nodecomp(const void *elem1, const void *elem2)
{
return (((GTS_NODE_ORDER *)elem1)->depth - ((GTS_NODE_ORDER *)elem2)->depth);
}
//
//
void GTSCacheGenerator::SaveNetItem(CPtrList *nsp, BNTS *bp, FILE *fp, LPCSTR name)
{
GTS_NODE_ITEM *ni;
if (!bp->BNetPropItemStr( name, 0 ))
return;
ni = new GTS_NODE_ITEM(name);
int j = 0;
while (bp->BNetPropItemStr( name, j++ ))
{
CString sTemp = bp->SzcResult();
ni->sStringArr.Add(sTemp);
}
nsp->AddTail(ni);
}
//
//
BOOL GTSCacheGenerator::NodeTraverse( FILE *fp,
BNTS *bp,
int depth,
CArray<int,int> &newnodes,
CArray<int,int> &newstates,
int currnode,
int currstate)
{
BOOL bEnd = FALSE;
int i, j;
if (depth > 30)
{
LogOut(_T("Depth Exceeded\n"));
return FALSE;
}
// uninstantiate
UninstantiateAll(bp);
newnodes.Add(currnode);
newstates.Add(currstate);
depth++;
for (i=0;i<newnodes.GetSize();i++)
{
if (bp->BNodeSetCurrent(newnodes[i]))
{
bp->NodeSymName();
CString sTemp = bp->SzcResult();
LogOut(_T("%s"), sTemp);
ESTDLBL albl = bp->ELblNode();
if (albl == ESTDLBL_problem)
{
LogOut(_T("(prob)"));
}
else if (albl == ESTDLBL_info)
{
LogOut(_T("(info)"));
}
else if (albl == ESTDLBL_fixobs ||
albl == ESTDLBL_fixunobs ||
albl == ESTDLBL_unfix)
{
LogOut(_T("(fix)"));
}
else
{
LogOut(_T("(?)"));
}
}
LogOut(_T("(%d=%d) "), newnodes[i], newstates[i]);
}
SetNodes( bp, newnodes, newstates );
BOOL bRec = FALSE;
if (!bp->BGetRecommendations())
{
bRec = TRUE;
}
else
{
}
const int *rg = bp->RgInt();
i = 0;
if (bRec)
{
if (bp->BImpossible())
{
LogOut(_T("IMPOSSIBLE\n"));
}
else
{
LogOut(_T("RECOMMENDATION ERROR\n"));
}
}
else
{
if (bp->BImpossible())
{
LogOut(_T("IMPOSSIBLE (Have Rec)\n"));
}
else
{
int reccount = bp->CInt();
if (reccount)
{
int nodecount = (int)newstates.GetSize();
if (nodecount)
{
BOOL bFound = FALSE;
for (i=0;i<reccount;i++)
{
bFound = FALSE;
for (j=0;j<nodecount;j++)
{
if (newnodes[j] == rg[i])
{
bFound = TRUE;
break;
}
}
if (!bFound)
break;
}
if (!bFound)
{
LogOut(_T("RECOMMENDATION: "));
if (bp->BNodeSetCurrent(rg[i]))
{
CString sTemp1 = "Error";
CString sTemp2 = "Error";
if (bp->BNodePropItemStr( "HNodeHd", 0 ))
sTemp1 = bp->SzcResult();
bp->NodeSymName();
sTemp2 = bp->SzcResult();
LogOut(_T("%s (%s) (Node: %d)"), sTemp1, sTemp2, rg[i]);
if (m_nodeorder)
{
if (m_nodeorder[rg[i]].depth > depth)
m_nodeorder[rg[i]].depth = depth;
}
UINT realcount = 0;
for (j=0;j<nodecount;j++)
if (newstates[j] != STATE_UNKNOWN)
realcount++;
fwrite(&realcount, sizeof (UINT), 1, fp);
for (j=0;j<nodecount;j++)
if (newstates[j] != STATE_UNKNOWN)
{
GTS_CACHE_NODE cnode;
cnode.node = newnodes[j];
cnode.state = newstates[j];
fwrite(&cnode, sizeof (cnode), 1, fp);
}
// write to cache out file
UINT ucount = reccount;
fwrite(&ucount, sizeof (UINT), 1, fp);
for (j=0;j<reccount;j++)
{
UINT rgval = rg[j];
fwrite(&rgval, sizeof (UINT), 1, fp);
}
m_nCount++;
}
LogOut(_T("\n"));
}
else
{
LogOut(_T("NO RECOMMENDATIONS - ALL AVAILABLE MARKED AS UNKNOWN\n"));
bEnd = TRUE;
}
}
else
LogOut(_T("STATE COUNT 0 - INTERNAL ERROR\n"));
}
else
LogOut(_T("NO RECOMMENDATIONS\n"));
}
}
LogOut(_T("\n"));
// recommendations - let's figure out what to do with them
// the first rec in the returned array will be array[1] in the set array
// so we have to watch for that
if (bp->CInt() && !bEnd)
{
// have rec
CArray<int,int> states;
int node = rg[i];
if (bp->BNodeSetCurrent(node))
{
ESTDLBL albl = bp->ELblNode();
if (albl == ESTDLBL_info)
{
states.Add(0);
states.Add(1);
if (m_bScanAll)
states.Add(STATE_UNKNOWN);
}
else if (albl == ESTDLBL_fixobs ||
albl == ESTDLBL_fixunobs ||
albl == ESTDLBL_unfix)
{
states.Add(0);
if (m_bScanAll)
states.Add(STATE_UNKNOWN);
}
else
{
LogOut(_T("Unexpected Node Type\n"));
}
}
else
LogOut(_T("Can't set node current\n"));
int count = (int)states.GetSize();
for (i=0;i<count;i++)
{
if (!NodeTraverse( fp, bp, depth, newnodes, newstates, node, states[i] ))
return FALSE;
}
}
// done, remove references to our current node
newnodes.RemoveAt(depth - 1);
newstates.RemoveAt(depth - 1);
return TRUE;
}
//
//
void GTSCacheGenerator::UninstantiateAll(BNTS *bp)
{
int count = (int)m_oldnodes.GetSize();
// uninstantiate all nodes
if (!count)
return;
for (int j=0;j<count;j++)
{
if (bp->BNodeSetCurrent(m_oldnodes[j]))
{
if (bp->BNodeSet(-1))
{
}
else
{
LogOut(_T("Can't uninstantiate node\n"));
}
}
else
{
LogOut(_T("Can't set node %d to uninstantiate\n"), m_oldnodes[j]);
}
}
}
//
//
void GTSCacheGenerator::SetNodes(BNTS *bp, CArray<int,int> &nodes, CArray<int,int> &states)
{
m_oldnodes.Copy(nodes);
int count = (int)nodes.GetSize();
if (!count)
return;
LogOut(_T("\nSetNodes:"));
for (int j=0;j<count;j++)
{
if (bp->BNodeSetCurrent(nodes[j]))
{
if (states[j] != STATE_UNKNOWN)
{
LogOut(_T("(%d=%d)"), nodes[j], states[j]);
if (bp->BNodeSet(states[j], false))
{
}
else
{
LogOut(_T("Can't set node\n"));
}
}
else
LogOut(_T("(%d=X)"), nodes[j]);
}
else
LogOut(_T("Can't set node %d\n"), nodes[j]);
}
LogOut(_T("\n"));
}
//
//
BOOL GTSCacheGenerator::ReadCacheFileHeader(CString &sCacheFilename, const CString& strCacheFileWithinCHM)
{
GTS_CACHE_FILE_HEADER header;
bool bUseCHM = strCacheFileWithinCHM.GetLength() != 0;
if (bUseCHM)
{
DWORD size =0;
if (S_OK != ::ReadChmFile(sCacheFilename, strCacheFileWithinCHM, (void**)&m_filedata, &size))
{
return FALSE;
}
}
else
{
UINT size;
// must be binary
FILE *cfp = _tfopen(sCacheFilename, _T("rb"));
if (cfp==NULL)
{
LogOut(_T("Error opening cache file for reading\n"));
return FALSE;
}
// get file size
if (fseek(cfp, 0, SEEK_END))
{
LogOut(_T("Can't set pos to end of file\n"));
fclose(cfp);
return FALSE;
}
fpos_t position;
if (fgetpos(cfp, &position))
{
LogOut(_T("Can't get pos at end of file\n"));
fclose(cfp);
return FALSE;
}
size = (UINT) position;
rewind(cfp);
// allocate space for file
m_filedata = (char *) malloc(size);
if (m_filedata == NULL)
{
LogOut(_T("Error allocating memory\n"));
fclose(cfp);
return FALSE;
}
if (fread(m_filedata, size, 1, cfp) != 1)
{
LogOut(_T("Error reading file into memory\n"));
fclose(cfp);
return FALSE;
}
fclose(cfp);
}
memcpy(&header, m_filedata, sizeof(header));
if (memcmp(header.signature, GTS_CACHE_SIG, sizeof (header.signature)) != 0)
{
LogOut(_T("Bad file signature!\n"));
return FALSE;
}
if (!header.count)
{
LogOut(_T("No items in file!\n"));
return FALSE;
}
m_netstartoffset = header.netoffset;
LogOut(_T("ItemCount: %d\n"), header.count);
m_nItemCount = header.count;
m_cachepos = (GTS_CACHE_FILE_SETDATA *) (m_filedata + sizeof (GTS_CACHE_FILE_HEADER));
return TRUE;
}
//
//
BOOL GTSCacheGenerator::FindNetworkProperty(LPCSTR szName, CString &sResult, int index)
{
if (m_filedata == NULL)
return FALSE;
GTS_CACHE_PROP_NETSTART_BLK *netstart =
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
GTS_CACHE_PROP_STR_BLK *netstrblk =
(GTS_CACHE_PROP_STR_BLK *) (m_filedata + netstart->netpropoffset);
for (UINT i = 0; i < netstart->netpropcount; i++, netstrblk++)
{
LPCSTR szItem = (LPCSTR) (m_filedata + netstrblk->nameoffset);
if (!strcmp(szName, szItem))
{
if (!index)
{
sResult = (LPCSTR) (m_filedata + netstrblk->stringoffset);
return TRUE;
}
else
{
LPCSTR szStrArrItem = (LPCSTR) (m_filedata + netstrblk->stringoffset);
int len = strlen(szStrArrItem);
for (int j=0;(j < index) && len ;j++)
{
szStrArrItem += len + 1;
len = strlen(szStrArrItem);
}
if (!len)
return FALSE;
sResult = szStrArrItem;
return TRUE;
}
}
}
return FALSE;
}
//
//
BOOL GTSCacheGenerator::FindNodeProperty(UINT nodeid, LPCSTR szName, CString &sResult, int index)
{
if (m_filedata == NULL)
return FALSE;
GTS_CACHE_PROP_NETSTART_BLK *netstart =
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
{
if (nodeid == nodeblk->nodeid)
{
GTS_CACHE_PROP_NODESTART_BLK *nodestart =
(GTS_CACHE_PROP_NODESTART_BLK *)(m_filedata + nodeblk->nodeoffset);
GTS_CACHE_PROP_STR_BLK *nodestr =
(GTS_CACHE_PROP_STR_BLK *)(m_filedata + nodeblk->nodeoffset + sizeof (GTS_CACHE_PROP_NODESTART_BLK));
// now try to find string
for (UINT j=0;j<nodestart->nodestringcount;j++, nodestr++)
{
LPCSTR szItem = (LPCSTR) (m_filedata + nodestr->nameoffset);
if (!strcmp(szName, szItem))
{
if (!index)
{
sResult = (LPCSTR) (m_filedata + nodestr->stringoffset);
return TRUE;
}
else
{
LPCSTR szStrArrItem = (LPCSTR) (m_filedata + nodestr->stringoffset);
int len = strlen(szStrArrItem);
for (int j=0;(j < index) && len ;j++)
{
szStrArrItem += len + 1;
len = strlen(szStrArrItem);
}
if (!len)
return FALSE;
sResult = szStrArrItem;
return TRUE;
}
}
}
return FALSE;
}
}
return FALSE;
}
//
//
BOOL GTSCacheGenerator::IsNodePresent(UINT nodeid)
{
if (m_filedata == NULL)
return FALSE;
GTS_CACHE_PROP_NETSTART_BLK *netstart =
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
{
if (nodeid == nodeblk->nodeid)
return TRUE;
}
return FALSE;
}
// returns the node count for the network, not what's in the file
//
int GTSCacheGenerator::GetNodeCount()
{
if (m_filedata == NULL)
return 0;
GTS_CACHE_PROP_NETSTART_BLK *netstart =
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
return netstart->nodecountnetwork;
}
//
//
BOOL GTSCacheGenerator::GetNodeIDFromSymName(LPCTSTR szSymName, UINT &nodeid)
{
char sznSymName[MAX_SYM_NAME_BUF_LEN];
int nSymLen = MAX_SYM_NAME_BUF_LEN;
if (m_filedata == NULL)
return FALSE;
if (!TcharToChar(sznSymName, szSymName, nSymLen))
return FALSE;
GTS_CACHE_PROP_NETSTART_BLK *netstart =
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
{
GTS_CACHE_PROP_NODESTART_BLK *nodestart =
(GTS_CACHE_PROP_NODESTART_BLK *)(m_filedata + nodeblk->nodeoffset);
GTS_CACHE_PROP_STR_BLK *nodestr =
(GTS_CACHE_PROP_STR_BLK *)(m_filedata + nodeblk->nodeoffset + sizeof (GTS_CACHE_PROP_NODESTART_BLK));
// now try to find string
for (UINT j=0;j<nodestart->nodestringcount;j++, nodestr++)
{
LPCSTR szItem = (LPCSTR) (m_filedata + nodestr->nameoffset);
if (!strcmp(G_SYMBOLIC_NAME, szItem))
{
if (!strcmp(sznSymName, (LPCSTR) (m_filedata + nodestr->stringoffset)))
{
nodeid = nodeblk->nodeid;
return TRUE;
}
break;
}
}
}
return FALSE;
}
//
//
BOOL GTSCacheGenerator::GetLabelOfNode(UINT nodeid, UINT &lbl)
{
if (m_filedata == NULL)
return FALSE;
GTS_CACHE_PROP_NETSTART_BLK *netstart =
(GTS_CACHE_PROP_NETSTART_BLK *)(m_filedata + m_netstartoffset);
GTS_CACHE_PROP_NODEOFF_BLK *nodeblk =
(GTS_CACHE_PROP_NODEOFF_BLK *) (m_filedata + m_netstartoffset + sizeof (GTS_CACHE_PROP_NETSTART_BLK));
for (UINT i = 0; i < netstart->nodecountfile; i++, nodeblk++)
{
if (nodeid == nodeblk->nodeid)
{
GTS_CACHE_PROP_NODESTART_BLK *nodestart =
(GTS_CACHE_PROP_NODESTART_BLK *)(m_filedata + nodeblk->nodeoffset);
lbl = nodestart->labelnode;
return TRUE;
}
}
return FALSE;
}
//
//
BOOL GTSCacheGenerator::GetNextCacheEntryFromFile(BOOL &bErr, CBNCache *pCache)
{
BOOL bStat = FALSE;
bErr = TRUE;
if (m_filedata == NULL)
return FALSE;
if (!m_nItemCount)
{
bErr = FALSE;
return FALSE;
}
m_nItemCount--;
BN_CACHE_ITEM CacheItem;
// initialize
CacheItem.uNodeCount = 0;
CacheItem.uRecCount = 0;
CacheItem.uName = NULL;
CacheItem.uValue = NULL;
CacheItem.uRec = NULL;
bStat = GetNCEFF(&CacheItem, pCache);
// free allocated space as necessary
if (CacheItem.uName)
free(CacheItem.uName);
if (CacheItem.uValue)
free(CacheItem.uValue);
if (CacheItem.uRec)
free(CacheItem.uRec);
if (!bStat)
{
bErr = TRUE;
return FALSE;
}
bErr = FALSE;
return TRUE;
}
//
//
BOOL GTSCacheGenerator::GetNCEFF(BN_CACHE_ITEM *pCacheItem, CBNCache *pCache)
{
UINT j;
UINT setcount;
UINT reccount;
GTS_CACHE_FILE_SETDATA *setp = m_cachepos;
setcount = setp->count;
if (!setcount || setcount > 1000)
{
LogOut(_T("Set Count out of bounds: %d\n"), setcount);
return FALSE;
}
// initialize
pCacheItem->uNodeCount = setcount;
pCacheItem->uName = (UINT *)malloc(setcount * sizeof (UINT));
pCacheItem->uValue = (UINT *)malloc(setcount * sizeof (UINT));
LogOut(_T("Count: %d\n"), setcount);
GTS_CACHE_NODE *cachenode = &setp->item[0];
// second, read in node = state pairs
for (j=0;j<setcount;j++, cachenode++)
{
pCacheItem->uName[j] = cachenode->node;
pCacheItem->uValue[j] = cachenode->state;
LogOut(_T("(%d,%d)"), cachenode->node, cachenode->state);
}
LogOut(_T("\n"));
GTS_CACHE_FILE_RECDATA *recp = (GTS_CACHE_FILE_RECDATA *) cachenode;
reccount = recp->count;
if (!reccount || reccount > 1000)
{
LogOut(_T("Rec Count out of bounds: %d\n"), reccount);
return FALSE;
}
pCacheItem->uRecCount = reccount;
pCacheItem->uRec = (UINT *)malloc(reccount * sizeof (UINT));
UINT *uitem = &recp->item[0];
for (j=0;j<reccount;j++, uitem++)
{
pCacheItem->uRec[j] = *uitem;
LogOut(_T("(%d)"), *uitem);
}
LogOut(_T("\n"));
if (!pCache->AddCacheItem(pCacheItem))
{
LogOut(_T("Error Adding Item To Cache\n"));
return FALSE;
}
m_cachepos = (GTS_CACHE_FILE_SETDATA *) uitem;
// success!
return TRUE;
}

Reference in a new issue Copy permalink