500 lines
15 KiB
C++
500 lines
15 KiB
C++
//
|
|
// MODULE: APGTSINF.H
|
|
//
|
|
// PURPOSE: Inference support header
|
|
//
|
|
// PROJECT: Generic Troubleshooter DLL for Microsoft AnswerPoint
|
|
//
|
|
// COMPANY: Saltmine Creative, Inc. (206)-633-4743 support@saltmine.com
|
|
//
|
|
// AUTHOR: Roman Mach
|
|
// further work by Richard Meadows (RWM), Joe Mabel, Oleg Kalosha
|
|
//
|
|
// ORIGINAL DATE: 8-2-96
|
|
//
|
|
// NOTES:
|
|
// 1. Based on Print Troubleshooter DLL
|
|
//
|
|
// Version Date By Comments
|
|
//--------------------------------------------------------------------
|
|
// V0.1 - RM Original
|
|
// V0.2 6/4/97 RWM Local Version for Memphis
|
|
// V0.3 3/24/98 JM Local Version for NT5
|
|
|
|
#include "ErrorEnums.h"
|
|
#include "sniff.h"
|
|
|
|
typedef unsigned int NID; // numeric node ID in the form used by BNTS
|
|
|
|
// Please Note: these values are mirrored in dtguiapi.bas, please keep in sync
|
|
const NID nidNil = 12346;
|
|
const NID nidService = 12345;
|
|
|
|
#define IDH_BYE 101 // success page
|
|
#define IDH_FAIL 102 // "no more recommendations" page
|
|
|
|
typedef UINT IDH; // help index. For values where a NID is defined,
|
|
// add idhFirst to get an IDH. IDH_BYE & IDH_FAIL
|
|
// are also good IDHs.
|
|
const IDH idhFirst = 1000;
|
|
#define IDH_FROM_NID(NID) (NID + idhFirst)
|
|
|
|
#define IDH_SERVICE IDH_FROM_NID(nidService)
|
|
|
|
#define MAXBUF 256 * 2
|
|
|
|
#define MAXPROBID 100 // allow for this many problem nodes in a network
|
|
|
|
enum { cnidMacSkip = 32 }; // max # of "skipped" nodes
|
|
|
|
typedef TCHAR* TSZ;
|
|
typedef const TCHAR* TSZC;// >>> why distinguished from TSZ?
|
|
|
|
typedef unsigned int CNID; // a count of node IDs.
|
|
typedef unsigned int IST; // state number (associated with a node)
|
|
// 0 - normal
|
|
// 1 - abnormal
|
|
// 102 - skipped
|
|
|
|
#define MAX_NID 64 // allow for this many nodes to be given states by user on the
|
|
// way to solving the problem
|
|
|
|
void WideToMB(const WCHAR *szIn, CHAR *szOut); // Converts Unicode chars to Multi Byte.
|
|
|
|
class GTSCacheGenerator; // forward reference
|
|
|
|
class GTSAPI : public BNTS
|
|
{
|
|
#define SZ_CACHE_NAME _T(".tsc")
|
|
public:
|
|
GTSAPI(TCHAR *binfile, TCHAR *tagstr, TCHAR *szResourcePath);
|
|
virtual ~GTSAPI();
|
|
BOOL BNodeSet(int state, bool bset); // Old comment says "For debugging" but I doubt it.
|
|
// Maybe that's just why its public. - JM 3/98
|
|
void AddValue(int value);
|
|
|
|
// Temporary BNTS wrappers for unicode build with non unicode bnts.dll
|
|
CString m_strResult;
|
|
BOOL BMultiByteReadModel(LPCTSTR szcFn, LPCSTR szcFnError);
|
|
BOOL BReadModel (LPCTSTR szcFn, LPCSTR szcFnError = NULL)
|
|
{
|
|
#ifndef _UNICODE
|
|
return BNTS::BReadModel(szcFn, szcFnError);
|
|
#else
|
|
return BMultiByteReadModel(szcFn, szcFnError);
|
|
#endif
|
|
};
|
|
BOOL BMultiByteNodePropItemStr(LPCTSTR szcPropType, int index);
|
|
virtual BOOL BNodePropItemStr(TSZC szcPropType, int index)
|
|
{
|
|
#ifndef _UNICODE
|
|
return BNTS::BNodePropItemStr(szcPropType, index);
|
|
#else
|
|
return BMultiByteNodePropItemStr(szcPropType, index);
|
|
#endif
|
|
};
|
|
BOOL BMultiByteNetPropItemStr(LPCTSTR szcPropType, int index);
|
|
virtual BOOL BNetPropItemStr(TSZC szcPropType, int index)
|
|
{
|
|
#ifndef _UNICODE
|
|
return BNTS::BNetPropItemStr(szcPropType, index);
|
|
#else
|
|
return BMultiByteNetPropItemStr(szcPropType, index);
|
|
#endif
|
|
};
|
|
LPCTSTR SzcMultiByteResult();
|
|
virtual LPCTSTR SzcResult()
|
|
{
|
|
#ifndef _UNICODE
|
|
return BNTS::SzcResult();
|
|
#else
|
|
return SzcMultiByteResult();
|
|
#endif
|
|
};
|
|
int IMultiByteNode(LPCTSTR szSymName);
|
|
virtual int INode(LPCTSTR szSymName)
|
|
{
|
|
#ifndef _UNICODE
|
|
return BNTS::INode(szSymName);
|
|
#else
|
|
return IMultiByteNode(szSymName);
|
|
#endif
|
|
};
|
|
|
|
|
|
// Temporary BNTS wrappers for debug build with release bnts.dll
|
|
/*
|
|
BOOL BNetPropItemStr(LPCTSTR szPropItem, int index, CString &str)
|
|
{
|
|
BOOL bRet;
|
|
str.GetBuffer(STRBUFSIZE);
|
|
bRet = BNTS::BNetPropItemStr(szPropItem, index, str);
|
|
str.ReleaseBuffer();
|
|
return bRet;
|
|
};
|
|
BOOL BNodePropItemStr(LPCTSTR szPropItem, int index, CString &str)
|
|
{
|
|
BOOL bRet;
|
|
str.GetBuffer(STRBUFSIZE);
|
|
bRet = BNTS::BNodePropItemStr(szPropItem, index, str);
|
|
str.ReleaseBuffer();
|
|
return bRet;
|
|
};
|
|
void NodeStateName(int index, CString &str)
|
|
{
|
|
str.GetBuffer(STRBUFSIZE);
|
|
BNTS::NodeStateName(index, str);
|
|
str.ReleaseBuffer();
|
|
return;
|
|
};
|
|
void NodeSymName(CString &str)
|
|
{
|
|
str.GetBuffer(STRBUFSIZE);
|
|
BNTS::NodeSymName(str);
|
|
str.ReleaseBuffer();
|
|
return;
|
|
};
|
|
void NodeFullName(CString &str)
|
|
{
|
|
str.GetBuffer(STRBUFSIZE);
|
|
BNTS::NodeFullName(str);
|
|
str.ReleaseBuffer();
|
|
return;
|
|
};
|
|
*/
|
|
// Regular functions.
|
|
|
|
//virtual BOOL NodeSet(NID nid, IST ist);
|
|
VOID ResetNodes();
|
|
|
|
DWORD Reload(/*CWordList *pWXList*/);
|
|
|
|
DWORD GetStatus();
|
|
|
|
UINT GetProblemArray(IDH **idh);
|
|
IDH GetProblemAsk();
|
|
|
|
UINT GetNodeList(NID **pNid, IST **pIst);
|
|
int GTSGetRecommendations(CNID& cnid, NID rgnid[]);
|
|
void RemoveRecommendation(int Nid);
|
|
|
|
VOID GetSearchWords(/*CWordList *pWords*/);
|
|
DWORD EvalWord(TCHAR *token);
|
|
|
|
//WNODE_ELEM *GetWNode(NID nid);
|
|
|
|
BOOL BNodeSetCurrent(int node);
|
|
|
|
|
|
VOID ScanAPIKeyWords(/*CWordList *pWXList*/);
|
|
|
|
protected:
|
|
VOID Destroy();
|
|
|
|
protected:
|
|
|
|
GTSCacheGenerator m_CacheGen;
|
|
|
|
// These 2 arrays tie together nodes & their states
|
|
NID m_rgnid[MAX_NID];
|
|
IST m_rgist[MAX_NID];
|
|
IST m_rgsniff[MAX_NID]; // array of states, showing if the node was sniffed
|
|
|
|
UINT m_cnid; // current size of m_rgnid, m_rgist; number of nodes to which
|
|
// a state has been assigned.
|
|
|
|
TCHAR m_binfile[MAXBUF]; // name of DSC file (>>> full path or not?)
|
|
// >>>should be renamed! DSC file replaced BIN file.
|
|
TCHAR m_tagstr[MAXBUF];
|
|
TCHAR m_szResourcePath[MAXBUF]; // full path of resource directory
|
|
|
|
DWORD m_dwErr;
|
|
|
|
TCHAR* m_pchHtml;
|
|
|
|
IDH m_idstore[MAXPROBID]; // problem node convenience array in the
|
|
// form of IDH values
|
|
UINT m_currid; // Despite bad name, number of values in m_idstore
|
|
IDH m_probask; // IDH value corresponding to ProblemAsk: number of nodes
|
|
// in the network + 1000
|
|
|
|
CBNCache *m_pCache; // cache for states of this network
|
|
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
// BCache class declaration
|
|
//
|
|
|
|
// these are returns by GTSGetRecommendations member function
|
|
//
|
|
#define RECOMMEND_SUCCESS 1
|
|
#define RECOMMEND_FAIL 0
|
|
#define RECOMMEND_IMPOSSIBLE 99
|
|
#define RECOMMEND_NODE_WORKED 100
|
|
#define RECOMMEND_NO_MORE_DATA 101
|
|
//
|
|
#define NODE_ID_NONE -1
|
|
//
|
|
|
|
class CHttpQuery;
|
|
|
|
class BCache : public GTSAPI, public CSniffedNodeContainer
|
|
{
|
|
public:
|
|
BCache(TCHAR *binfile, TCHAR *tagstr, TCHAR *szResourcePath, const CString& strFile);
|
|
~BCache();
|
|
|
|
void SetHttpQuery(CHttpQuery *p) {m_pHttpQuery = p;return;};
|
|
UINT StatesFromServ();
|
|
UINT StatesNowSet();
|
|
|
|
DWORD Initialize(/*CWordList *pWXList*/);
|
|
DWORD ReadModel();
|
|
void ReadCacheFile(LPCTSTR szCache);
|
|
|
|
int GTSGetRecommendations(CNID& cnid, NID rgnid[], bool bSniffed =false);
|
|
void RemoveRecommendation(int Nid);
|
|
BOOL NodeSet(NID nid, IST ist, bool bPrevious);
|
|
void ResetNodes();
|
|
|
|
int CNode();
|
|
BOOL BImpossible();
|
|
BOOL BNetPropItemStr(LPCTSTR szPropType, int index);
|
|
BOOL BNetPropItemReal(LPCTSTR szPropType, int index, double &dbl);
|
|
|
|
BOOL BNodeSetCurrent(int node);
|
|
int INode(LPCTSTR szNodeSymName);
|
|
ESTDLBL ELblNode();
|
|
int INodeCst();
|
|
BOOL BNodeSet(int istate, bool bSet = true);
|
|
int INodeState();
|
|
void NodeStateName(int istate);
|
|
void NodeSymName();
|
|
void NodeFullName();
|
|
BOOL BNodePropItemStr(LPCTSTR szPropType, int index);
|
|
BOOL BNodePropItenReal(LPCTSTR szPropType, int index, double &dbl);
|
|
void NodeBelief();
|
|
bool BValidNet();
|
|
bool BValidNode();
|
|
void Clear();
|
|
|
|
void RemoveStates() {m_NodeState.RemoveAll();};
|
|
void RemoveNode(int Node) {VERIFY(m_NodeState.RemoveKey(Node));};
|
|
|
|
LPCTSTR SzcResult() const;
|
|
|
|
void ReadTheDscModel(int From = TSERR_ENGINE_BNTS_READ);
|
|
|
|
const CArray<int, int>& GetArrLastSniffed();
|
|
|
|
int GetCountRecommendedNodes();
|
|
int GetCountSniffedRecommendedNodes();
|
|
|
|
bool IsReverse();
|
|
void SetReverse(bool);
|
|
|
|
void SetRunWithKnownProblem(bool);
|
|
bool IsRunWithKnownProblem();
|
|
|
|
void SetAdditionalDataOnNodeSet(NID nid);
|
|
|
|
protected:
|
|
int GetIndexNodeInCache(NID nid);
|
|
|
|
|
|
protected:
|
|
CHttpQuery *m_pHttpQuery;
|
|
BOOL CheckNode(int Node);
|
|
void AddToCache(CString &strCacheFile, const CString& strCacheFileWithinCHM);
|
|
|
|
BOOL m_bNeedModel; // TRUE -> Need to read the model before querying the bnts library.
|
|
BOOL m_bModelRead;
|
|
BOOL m_bDeleteModelFile;
|
|
CString m_strModelFile; // Filename of model file
|
|
CString m_strFile; // name of *.dsz or *.dsc file inside *.chm file
|
|
// (in this case network file is actually a *.chm file)
|
|
int m_CurNode;
|
|
CMap<int, int, int, int>m_NodeState;
|
|
|
|
CString m_strResult;
|
|
|
|
CArray<int, int> m_arrNidLastSniffed; // array in sniffed nodes traversed during last navigation
|
|
|
|
bool m_bReverse; // indicated if the current movement is in the forward or reverse direction
|
|
|
|
bool m_bRunWithKnownProblem; //indicates that the tshooter was started with known problem
|
|
};
|
|
|
|
typedef struct tag_TShooter
|
|
{
|
|
TCHAR m_szName[MAXBUF];
|
|
TCHAR m_szDisplayName[MAXBUF];
|
|
} TShooter;
|
|
|
|
//
|
|
//
|
|
class CInfer
|
|
{
|
|
|
|
public:
|
|
CInfer( CString *pCtxt);
|
|
~CInfer();
|
|
|
|
void ClearDoubleSkip() {m_SkippedTwice.RemoveAll();};
|
|
VOID AssertFailed(TSZC szcFile, UINT iline, TSZC szcCond, BOOL fFatal);
|
|
DWORD Initialize(/*CSearchForm *pBESearch*/);
|
|
void LoadTShooters(HKEY hRegKey);
|
|
int GetCount() {return m_acnid;};
|
|
|
|
void BackUp(int nid, int state);
|
|
void ClearBackup() {m_Backup.Clear();};
|
|
|
|
void WriteProblem();
|
|
BOOL FSetNodeOfIdh(IDH, IST);
|
|
int GetForcedRecommendation();
|
|
int Finish(CString *cstr);
|
|
void ResetService();
|
|
VOID PrintRecommendations();
|
|
VOID WriteOutLogs();
|
|
VOID SetBelief(BCache *pAPI);
|
|
TCHAR *EvalData(UINT var_index);
|
|
BOOL NextVar(UINT var_index);
|
|
BOOL InitVar(UINT var_index);
|
|
void SetProblemAsk();
|
|
void ClearProblemAsk();
|
|
void SetType(LPCTSTR type);
|
|
BOOL IsService(CString *cstr);
|
|
|
|
VOID RemoveSkips();
|
|
|
|
CSniffedNodeContainer* GetSniffedNodeContainer() {return m_api;}
|
|
|
|
protected:
|
|
|
|
void GetBackButton(CString &strBack);
|
|
void GetNextButton(CString &strNext);
|
|
void GetStartButton(CString &strStart);
|
|
void GetStd3ButtonEnList(CString *cstr, bool bIncludeBackButton, bool bIncludeNextButton, bool bIncludeStartButton);
|
|
|
|
bool GetNetPropItemStrs(TSZC item, UINT Res, CString *cstr);
|
|
bool GetNodePropItemStrs(TSZC item, UINT Res, CString *cstr);
|
|
VOID GetByeMsg(LPCTSTR szIdh, CString *cstr);
|
|
VOID GetFailMsg(LPCTSTR szIdh, CString *cstr);
|
|
VOID GetServiceMsg(LPCTSTR szIdh, CString *cstr);
|
|
VOID GetSkippedNodesMsg(LPCTSTR szIdh, CString *cstr);
|
|
VOID GetImpossibleNodesMsg(LPCTSTR szIdh, CString *cstr);
|
|
VOID GetFixRadios(LPCTSTR szIdh, CString *cstr);
|
|
VOID GetInfoRadios(LPCTSTR szIdh, CString *cstr);
|
|
VOID PrintMessage(TSZC szcFormat, ...) const;
|
|
VOID PrintString(TSZC szcFormat, ...) const;
|
|
void WriteResult(UINT name, UINT value, BOOL bSet, TSZC szctype, CString *cstr) const;
|
|
VOID CloseTable();
|
|
BOOL FxGetNode(NID nid, BOOL fStatus, CString *cstr) const;
|
|
void FxGetState(CString *cstr);
|
|
void FxInitState(NID nid);
|
|
VOID GetIdhPage(IDH idh, CString *cstr);
|
|
bool BelongsOnProblemPage(int index);
|
|
VOID GetIdhProblemPage(IDH idh, CString *cstr);
|
|
|
|
VOID OutputBackend(CString *cstr) const;
|
|
BOOL DisplayTerms(/*CWordList *pWords, */CString *cstr, BOOL bText, BOOL bOr) const;
|
|
|
|
VOID AddBackendDebug(CString *cstr) const;
|
|
|
|
void GetTS(CString *pCtmp);
|
|
|
|
private:
|
|
VOID AddSkip(NID nid);
|
|
BOOL FSkip(NID nid) const;
|
|
void SaveNID(UINT nid);
|
|
|
|
|
|
private:
|
|
CBackupInfo m_Backup;
|
|
UINT m_cnidSkip; // count of elements in m_rgnidSkip
|
|
NID m_rgnidSkip[cnidMacSkip]; // nodes for which the user has been unable to give
|
|
// a yes or no answer.
|
|
UINT m_ilineStat;
|
|
BOOL m_fDone; // (>>> Not well-understood 11/04/97 JM)
|
|
// Set TRUE when we write out service, fail, or
|
|
// success page, but there's some scenario where
|
|
// we clear it "so that the Previous button will work"
|
|
// on BYE page"
|
|
|
|
UINT m_ishowService; // >>> (JM 12/97) I suspect this is the same as OnlineTS's
|
|
// BOOL m_bAnythingElse; which is documented as
|
|
// Set TRUE if user wants to see if there is anything
|
|
// else they can try (obtained from a service node in the
|
|
// previous call to the DLL
|
|
IDH m_idhQuestion; // >>> (JM 12/97) I suspect this is the same as OnlineTS's
|
|
// NID m_nidAnythingElse; which is documented as
|
|
// Node to use if m_bAnythingElse is TRUE
|
|
|
|
private:
|
|
CString *m_pCtmp; // (uses new) just a scratch buffer
|
|
int m_cShooters; // a count of troubleshooting belief networks. JM strongly
|
|
// suspects 3/98 that in Local TS it never gets past 1.
|
|
// >>> presumably count of m_aShooters, so why don't we just
|
|
// use GetCount(), anyway?.
|
|
int m_iShooter; // index of a troubleshooting belief network. JM strongly
|
|
// suspects 3/98 that in Local TS it is always 0.
|
|
// presumably index into m_aShooters.
|
|
CMap<int, int, int, int>m_SkippedTwice;
|
|
CArray<TShooter, TShooter &> m_aShooters;
|
|
NID m_cnid; // number of positions used in m_rgnid
|
|
NID m_rgnid[64]; // node numbers of recommendations the user has visited
|
|
NID m_question_rgnid[64]; // new recommendations. We only care about the first
|
|
// recommendation not already offered and skipped.
|
|
UINT m_cur_rec; // index into m_rgnid. We use this to loop through as we write
|
|
// the "visited node table"
|
|
UINT m_max_rec; // number of defined values in m_question_rgnid
|
|
UINT m_cur_rec_inid;
|
|
|
|
// The next 3 variables deal with states of a single node N, typically m_rgnid[m_cur_rec]
|
|
UINT m_cur_state_set; // state value of node N
|
|
UINT m_cur_cst; // count of states of node N
|
|
UINT m_cur_ist; // index into states of node N, used to build a list of radio
|
|
// buttons and log entries.
|
|
|
|
UINT m_problemAsk; // >>> A thinly disguised Boolean. >>>(I think) something to do with
|
|
// whether we return data on the problem node (vs. state-dependent
|
|
// data) JM 10/30//97
|
|
TCHAR m_problem[200]; // once a problem is chosen, this is where we put the associated
|
|
// text description of the problem. Full text description plus
|
|
// a hidden data field.
|
|
NID m_firstNid;
|
|
UINT m_firstSet;
|
|
TCHAR m_tstype[30]; // symbolic name of troubleshooter
|
|
//
|
|
// now in the CSniffedContainer object
|
|
/*
|
|
IDH m_idhSniffedRecommendation; // if a recommendation from a sniffer overrides normal
|
|
// method of getting a recommendation, here's where we store it.
|
|
// Otherwise, nidNil+idhFirst.
|
|
*/
|
|
|
|
protected:
|
|
TSZ m_szFile;
|
|
FILE* m_pfile;
|
|
BOOL m_bHttp;
|
|
CHAR m_szTemp1[MAXBUF];
|
|
CString *m_pCtxt; // points to a buffer passed in to constructor. This is where
|
|
// we build the HTML to pass back to the user
|
|
TCHAR m_currdir[MAXBUF];
|
|
CString *m_pResult; // A string to indicate (in the log) a FINAL result of a
|
|
// Troubleshoot session. e.g. ">Success", ">Nothing Else",
|
|
// ">Anything Else?", ">Help Elsewhere"
|
|
CString *m_pSearchStr; // a string consisting of the search words implied by our node
|
|
// choices, separated by "and" or "or" (depending on the
|
|
// value of m_pBESearch->IsAND). Used as part of Back End
|
|
// Search redirection. >>> Probably irrelevant to Local TS,
|
|
// which doesn't use BES
|
|
BCache *m_api; // cache for associated belief network
|
|
BOOL m_bService;
|
|
NID m_nidPreloadCheck;
|
|
CNID m_acnid; // count of nodes at *m_api
|
|
};
|
|
|