166 lines
3.7 KiB
C++
166 lines
3.7 KiB
C++
//
|
|
// MODULE: SNIFF.CPP
|
|
//
|
|
// PURPOSE: sniffing class
|
|
//
|
|
// COMPANY: Saltmine Creative, Inc. (206)-284-7511 support@saltmine.com
|
|
//
|
|
// AUTHOR: Oleg Kalosha
|
|
//
|
|
// ORIGINAL DATE: 12-11-98
|
|
//
|
|
// NOTES: This is base abstract class which performs sniffing
|
|
//
|
|
// Version Date By Comments
|
|
//--------------------------------------------------------------------
|
|
// V3.2 12-11-98 OK
|
|
//
|
|
|
|
#pragma warning(disable:4786)
|
|
#include "stdafx.h"
|
|
#include "Sniff.h"
|
|
#include "SniffConnector.h"
|
|
#include "SniffController.h"
|
|
#include "Topic.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[]=__FILE__;
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
// the problem is, that JavaScript returns 0xffffffff, but VBScript returns
|
|
// 0x0000ffff, so we define SNIFF_FAIL_MASK as 0x0000ffff and use it as mask to
|
|
// determine if sniffing was successful. Expression 0xffffffff & SNIFF_FAIL_MASK
|
|
// will have the same result as expression 0x0000ffff & SNIFF_FAIL_MASK.
|
|
// This define SHOULD NOT BE USED OUTSIDE THIS FILE!
|
|
#define SNIFF_FAIL_MASK 0x0000ffff
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
// CSniff implementation
|
|
|
|
// called as public interface function when resniffing
|
|
bool CSniff::Resniff(CSniffedArr& arrSniffed)
|
|
{
|
|
bool ret = false;
|
|
|
|
LOCKOBJECT();
|
|
|
|
for (CSniffedArr::iterator i = arrSniffed.begin(); i < arrSniffed.end(); i++)
|
|
{
|
|
IST state = SNIFF_FAILURE_RESULT;
|
|
|
|
if (GetSniffController()->AllowResniff(i->nid()))
|
|
{
|
|
if (SniffNodeInternal(i->nid(), &state))
|
|
{
|
|
if (state != i->state())
|
|
{
|
|
*i = CNodeStatePair(i->nid(), state);
|
|
ret = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arrSniffed.erase(i);
|
|
i--;
|
|
ret = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
UNLOCKOBJECT();
|
|
return ret;
|
|
}
|
|
|
|
// called as public interface function when sniffing on start up
|
|
bool CSniff::SniffAll(CSniffedArr& arrOut)
|
|
{
|
|
bool ret = false;
|
|
vector<NID> arrNodes;
|
|
vector<ESTDLBL> arrTypeExclude;
|
|
|
|
LOCKOBJECT();
|
|
|
|
arrTypeExclude.push_back(ESTDLBL_problem);
|
|
arrOut.clear();
|
|
|
|
if (GetTopic()->GetNodeArrayExcludeType(arrNodes, arrTypeExclude))
|
|
{
|
|
for (vector<NID>::iterator i = arrNodes.begin(); i < arrNodes.end(); i++)
|
|
{
|
|
if (GetSniffController()->AllowAutomaticOnStartSniffing(*i))
|
|
{
|
|
IST state = SNIFF_FAILURE_RESULT;
|
|
|
|
if (SniffNodeInternal(*i, &state))
|
|
{
|
|
arrOut.push_back(CNodeStatePair(*i, state));
|
|
ret = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UNLOCKOBJECT();
|
|
return ret;
|
|
}
|
|
|
|
// called as public interface function when sniffing on the fly
|
|
bool CSniff::SniffNode(NID numNodeID, IST* pnumNodeState)
|
|
{
|
|
bool ret = false;
|
|
|
|
LOCKOBJECT();
|
|
|
|
if (GetSniffController()->AllowAutomaticOnFlySniffing(numNodeID))
|
|
ret = SniffNodeInternal(numNodeID, pnumNodeState);
|
|
|
|
UNLOCKOBJECT();
|
|
return ret;
|
|
}
|
|
|
|
bool CSniff::SniffNodeInternal(NID numNodeID, IST* pnumNodeState)
|
|
{
|
|
CString strNodeName;
|
|
|
|
if (!GetTopic()->IsRead())
|
|
return false;
|
|
|
|
strNodeName = GetTopic()->GetNodeSymName(numNodeID);
|
|
|
|
if (strNodeName.IsEmpty())
|
|
return false;
|
|
|
|
long res = GetSniffConnector()->PerformSniffing(strNodeName, _T(""), _T(""));
|
|
|
|
if ((res & SNIFF_FAIL_MASK) == SNIFF_FAIL_MASK)
|
|
{
|
|
*pnumNodeState = SNIFF_FAILURE_RESULT;
|
|
return false;
|
|
}
|
|
|
|
*pnumNodeState = res;
|
|
return true;
|
|
}
|
|
|
|
void CSniff::SetAllowAutomaticSniffingPolicy(bool set)
|
|
{
|
|
GetSniffController()->SetAllowAutomaticSniffingPolicy(set);
|
|
}
|
|
|
|
void CSniff::SetAllowManualSniffingPolicy(bool set)
|
|
{
|
|
GetSniffController()->SetAllowManualSniffingPolicy(set);
|
|
}
|
|
|
|
bool CSniff::GetAllowAutomaticSniffingPolicy()
|
|
{
|
|
return GetSniffController()->GetAllowAutomaticSniffingPolicy();
|
|
}
|
|
|
|
bool CSniff::GetAllowManualSniffingPolicy()
|
|
{
|
|
return GetSniffController()->GetAllowManualSniffingPolicy();
|
|
}
|