1234 lines
25 KiB
C++
1234 lines
25 KiB
C++
// Copyright (c) 1999-2001 Microsoft Corporation, All Rights Reserved
|
|
#include <windows.h>
|
|
#include <snmptempl.h>
|
|
#include <snmpmt.h>
|
|
#include <typeinfo.h>
|
|
#include <process.h>
|
|
#include <objbase.h>
|
|
#include <stdio.h>
|
|
#include <wbemidl.h>
|
|
#include "classfac.h"
|
|
#include "guids.h"
|
|
#include <snmpevt.h>
|
|
#include <snmpthrd.h>
|
|
#include <snmplog.h>
|
|
#include <snmpcl.h>
|
|
#include <instpath.h>
|
|
#include <snmpcont.h>
|
|
#include <snmptype.h>
|
|
#include <snmpauto.h>
|
|
#include <snmpobj.h>
|
|
#include <genlex.h>
|
|
#include <sql_1.h>
|
|
#include <objpath.h>
|
|
#include "wndtime.h"
|
|
#include "rmon.h"
|
|
|
|
|
|
#define NUMBER_OF_RMON_INTERFACES 3
|
|
|
|
#define SYSTEM_INST L"MS_SNMP_RFC1213_MIB_system=@"
|
|
#define SYS_DESCR_PROP L"sysDescr"
|
|
#define SYS_DESCR_VAL L"SuperStack II Enterprise Monitor - Multi (2.95)"
|
|
#define PROVTOPN_CLASS L"MS_SNMP_RFC1271_MIB_ProvidedhostTopNTable"
|
|
#define TOPN_CLASS L"MS_SNMP_RFC1271_MIB_hostTopNTable"
|
|
#define TOPNINDEX_PROP L"hostTopNIndex"
|
|
#define TOPNREPORT_PROP L"hostTopNReport"
|
|
#define TOPNADDRESS_PROP L"hostTopNAddress"
|
|
#define TOPNRATE_PROP L"hostTopNRate"
|
|
#define CONFIGPATH L"RmonConfigClass = @"
|
|
#define FIRSTPOLL_PROP L"FirstDataPollPeriodSecs"
|
|
#define DATAPOLL_PROP L"DataPollPeriodSecs"
|
|
#define DATAOFFSET_PROP L"GetDataOffsetTenthSecs"
|
|
#define RETRYPOLL_PROP L"GetDataRetryTenthSecs"
|
|
#define SIZEN_PROP L"TopNSize"
|
|
#define STATSTYPE_PROP L"TopNStatisticType"
|
|
#define START_INDEX_PROP L"startingIndex"
|
|
#define SETCONF_CLASS L"MS_SNMP_RFC1271_MIB_hostTopNControlTableSetStatus"
|
|
#define CONF_CLASS L"MS_SNMP_RFC1271_MIB_hostTopNControlTable"
|
|
#define DURATIONCONF_CLASS L"MS_SNMP_RFC1271_MIB_hostTopNControlTableSetDuration"
|
|
#define CONFINDEX_PROP L"hostTopNControlIndex"
|
|
#define CONFHOSTINDEX_PROP L"hostTopNHostIndex"
|
|
#define CONFSTATUS_PROP L"hostTopNStatus"
|
|
#define CONFDURATION_PROP L"hostTopNTimeRemaining"
|
|
#define CONFOWNER_PROP L"hostTopNOwner"
|
|
#define CONFRATE_PROP L"hostTopNRateBase"
|
|
#define CONFSIZE_PROP L"hostTopNRequestedSize"
|
|
#define CRQ_CONFSTATUS_PROP_VAL L"createRequest"
|
|
#define VAL_CONFSTATUS_PROP_VAL L"valid"
|
|
#define DEL_CONFSTATUS_PROP_VAL L"invalid"
|
|
#define CONFOWNER_PROP_VAL L"Steve & Nadir's Demonstration"
|
|
#define HOST_CLASS L"MS_SNMP_RFC1271_MIB_hostTable"
|
|
#define HOSTINDEX_PROP L"hostIndex"
|
|
#define HOSTADDRESS_PROP L"hostAddress"
|
|
#define HOSTINOCT_PROP L"hostInOctets"
|
|
#define HOSTINPKT_PROP L"hostInPkts"
|
|
#define HOSTOUTBCAST_PROP L"hostOutBroadcastPkts"
|
|
#define HOSTOUTERROR_PROP L"hostOutErrors"
|
|
#define HOSTOUTMCAST_PROP L"hostOutMulticastPkts"
|
|
#define HOSTOUTOCT_PROP L"hostOutOctets"
|
|
#define HOSTOUTPKT_PROP L"hostOutPkts"
|
|
#define DOT_CHAR L'.'
|
|
#define EQUALS_CHAR L'='
|
|
#define QUOTE_CHAR L'\"'
|
|
#define COMMA_CHAR L','
|
|
|
|
|
|
RmonConfigData::RmonConfigData(const ULONG poll, const ULONG firstpoll, const ULONG data,
|
|
const ULONG dataretry, const ULONG size, BSTR stats, const ULONG index)
|
|
{
|
|
SetPollPeriod(poll);
|
|
SetInitialPeriod(firstpoll);
|
|
SetDataOffset(data);
|
|
SetDataRetry(dataretry);
|
|
SetNSize(size);
|
|
SetIndex(index);
|
|
m_statstype = stats;
|
|
}
|
|
|
|
void RmonConfigData::SetStatsType(BSTR val)
|
|
{
|
|
if (NULL != m_statstype)
|
|
{
|
|
SysFreeString(m_statstype);
|
|
}
|
|
|
|
m_statstype = val;
|
|
}
|
|
|
|
|
|
ULONG TopNTableStore::GetKey(IWbemClassObject *obj)
|
|
{
|
|
ULONG ret = 0;
|
|
|
|
VARIANT v;
|
|
|
|
BSTR propstr = SysAllocString(TOPNREPORT_PROP);
|
|
|
|
if (NULL != propstr)
|
|
{
|
|
HRESULT result = obj->Get(propstr, 0, &v, NULL, NULL);
|
|
SysFreeString(propstr);
|
|
|
|
if ((WBEM_NO_ERROR == result) && (VT_I4 == v.vt))
|
|
{
|
|
propstr = SysAllocString(TOPNINDEX_PROP);
|
|
|
|
if (NULL != propstr)
|
|
{
|
|
ULONG topNr = v.lVal;
|
|
result = obj->Get(propstr, 0, &v, NULL, NULL);
|
|
SysFreeString(propstr);
|
|
|
|
if((WBEM_NO_ERROR == result) && (VT_I4 == v.vt))
|
|
{
|
|
ret = GetKey(topNr, v.lVal);
|
|
}
|
|
else if (WBEM_NO_ERROR == result)
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else if (WBEM_NO_ERROR == result)
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
ULONG TopNTableStore::GetKey(ULONG topNReport, ULONG topNIndex)
|
|
{
|
|
return ( (topNReport << 16) | (topNIndex & 65535) );
|
|
}
|
|
|
|
|
|
BOOL TopNTableProv::InitializeRmon()
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
if (!GetRmonConfData())
|
|
{
|
|
//set error object
|
|
}
|
|
else
|
|
{
|
|
if (!DeleteRmonConfiguration())
|
|
{
|
|
//set error object?? or write a message somewhere??
|
|
}
|
|
|
|
LONG status = SetRmonConfiguration();
|
|
|
|
if (status != 0) //at least one subnet being monitored
|
|
{
|
|
if (status == -1)
|
|
{
|
|
//not all subnets being monitored
|
|
}
|
|
|
|
ret = TRUE;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
BOOL TopNTableProv::GetWBEMEnumerator(IEnumWbemClassObject **ppEnum, wchar_t *strclass)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
HRESULT result = m_wbemServ->CreateInstanceEnum(strclass, 0, NULL, ppEnum);
|
|
|
|
if ( (WBEM_NO_ERROR == result) && (WBEM_NO_ERROR == (*ppEnum)->Reset()) )
|
|
{
|
|
ret = TRUE;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
void TopNTableProv::Poll()
|
|
{
|
|
BOOL retry = FALSE;
|
|
IEnumWbemClassObject* pEnum;
|
|
|
|
if (GetWBEMEnumerator(&pEnum, TOPN_CLASS))
|
|
{
|
|
ULONG returned;
|
|
IWbemClassObject* pObj;
|
|
HRESULT result = pEnum->Next(-1,1, &pObj, &returned);
|
|
|
|
if (WBEM_NO_ERROR != result)
|
|
{
|
|
pEnum->Release();
|
|
pEnum = NULL;
|
|
retry = TRUE;
|
|
}
|
|
else
|
|
{
|
|
GetData(pEnum, pObj);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retry = TRUE;
|
|
}
|
|
|
|
if (retry)
|
|
{
|
|
m_Status = RETRY_ENUM_STATUS;
|
|
m_Strobing = TRUE;
|
|
}
|
|
}
|
|
|
|
void TopNTableProv::RetryPoll()
|
|
{
|
|
|
|
BOOL reset = FALSE;
|
|
IEnumWbemClassObject* pEnum;
|
|
|
|
if (GetWBEMEnumerator(&pEnum, TOPN_CLASS))
|
|
{
|
|
ULONG returned;
|
|
IWbemClassObject* pObj;
|
|
HRESULT result = pEnum->Next(-1,1, &pObj, &returned);
|
|
|
|
if (WBEM_NO_ERROR != result)
|
|
{
|
|
pEnum->Release();
|
|
pEnum = NULL;
|
|
reset = TRUE;
|
|
}
|
|
else
|
|
{
|
|
GetData(pEnum, pObj);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reset = TRUE;
|
|
}
|
|
|
|
if (reset)
|
|
{
|
|
m_CacheAge++;
|
|
|
|
if (NULL != m_FirstTimeWait)
|
|
{
|
|
m_FirstTimeWait->Set();
|
|
}
|
|
|
|
ResetRmonDuration();
|
|
m_Status = POLL_ENUM_STATUS;
|
|
m_Strobing = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL TopNTableProv::CopyEntry(IWbemClassObject** pDest, IWbemClassObject* pSource)
|
|
{
|
|
VARIANT v;
|
|
ULONG topNReport = 0;
|
|
|
|
if (*pDest == NULL)
|
|
{
|
|
//create the class as pDest and add the two indices...,
|
|
if (WBEM_NO_ERROR != m_pObjProv->SpawnInstance(0, pDest))
|
|
{
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (!GetWBEMProperty(pSource, v, TOPNREPORT_PROP))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//only want results for entries we configured
|
|
if ( (v.vt == VT_I4) &&
|
|
(v.lVal < (m_Confdata.GetIndex() + NUMBER_OF_RMON_INTERFACES)) &&
|
|
(v.lVal >= m_Confdata.GetIndex()) )
|
|
{
|
|
if (!PutWBEMProperty(*pDest, v, TOPNREPORT_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
topNReport = v.lVal;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetWBEMProperty(pSource, v, TOPNINDEX_PROP))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) ||!PutWBEMProperty(*pDest, v, TOPNINDEX_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
|
|
//set the remaining properties from the TopNTable instance...
|
|
if (!GetWBEMProperty(pSource, v, TOPNRATE_PROP))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(*pDest, v, TOPNRATE_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pSource, v, TOPNADDRESS_PROP))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_BSTR) || !PutWBEMProperty(*pDest, v, TOPNADDRESS_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
return FALSE;
|
|
}
|
|
|
|
CString addrstr(v.bstrVal);
|
|
VariantClear(&v);
|
|
|
|
if (0 == topNReport) //only set if we spawned instance in this call
|
|
{
|
|
if (!GetWBEMProperty(pSource, v, TOPNREPORT_PROP))
|
|
{
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (v.vt != VT_I4)
|
|
{
|
|
VariantClear(&v);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
topNReport = v.lVal;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
|
|
return AddHostProperties(*pDest, topNReport, addrstr);
|
|
}
|
|
|
|
|
|
void TopNTableProv::GetData(IEnumWbemClassObject* pEnum, IWbemClassObject* psrcObj)
|
|
{
|
|
m_CacheAge = 0;
|
|
BOOL LoopOn = TRUE;
|
|
TopNCache *t_NoLockedStore = new TopNCache ;
|
|
|
|
m_CachedResults.Lock();
|
|
|
|
POSITION pos = m_CachedResults.m_pTopNCache->GetStartPosition();
|
|
while (NULL != pos)
|
|
{
|
|
IWbemClassObject *pObj;
|
|
ULONG keyval;
|
|
m_CachedResults.m_pTopNCache->GetNextAssoc(pos, keyval, pObj);
|
|
|
|
IWbemClassObject *t_Clone = NULL ;
|
|
HRESULT t_Result = pObj->Clone ( &t_Clone ) ;
|
|
t_NoLockedStore->SetAt ( keyval , t_Clone ) ;
|
|
}
|
|
|
|
m_CachedResults.Unlock () ;
|
|
|
|
TopNCache* tmpStore = new TopNCache;
|
|
|
|
while (LoopOn)
|
|
{
|
|
//copy pObj over to the store...
|
|
ULONG keyval = TopNTableStore::GetKey(psrcObj);
|
|
|
|
if (0 != keyval)
|
|
{
|
|
IWbemClassObject *pObj;
|
|
|
|
if (t_NoLockedStore->Lookup(keyval, pObj))
|
|
{
|
|
t_NoLockedStore->RemoveKey(keyval);
|
|
}
|
|
else
|
|
{
|
|
pObj = NULL;
|
|
}
|
|
|
|
if (CopyEntry(&pObj, psrcObj))
|
|
{
|
|
tmpStore->SetAt(keyval, pObj);
|
|
}
|
|
else
|
|
{
|
|
if (pObj != NULL)
|
|
{
|
|
pObj->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
psrcObj->Release();
|
|
psrcObj = NULL;
|
|
ULONG returned;
|
|
HRESULT result = pEnum->Next(-1,1, &psrcObj, &returned);
|
|
LoopOn = (WBEM_NO_ERROR == result);
|
|
}
|
|
|
|
pEnum->Release();
|
|
|
|
pos = t_NoLockedStore->GetStartPosition();
|
|
while (NULL != pos)
|
|
{
|
|
IWbemClassObject *pObj;
|
|
ULONG keyval;
|
|
t_NoLockedStore->GetNextAssoc(pos, keyval, pObj);
|
|
pObj->Release();
|
|
}
|
|
|
|
t_NoLockedStore->RemoveAll();
|
|
delete t_NoLockedStore ;
|
|
|
|
m_CachedResults.Lock () ;
|
|
|
|
pos = m_CachedResults.m_pTopNCache->GetStartPosition();
|
|
while (NULL != pos)
|
|
{
|
|
IWbemClassObject *pObj;
|
|
ULONG keyval;
|
|
m_CachedResults.m_pTopNCache->GetNextAssoc(pos, keyval, pObj);
|
|
pObj->Release();
|
|
}
|
|
|
|
m_CachedResults.m_pTopNCache->RemoveAll () ;
|
|
delete m_CachedResults.m_pTopNCache ;
|
|
|
|
m_CachedResults.m_pTopNCache = tmpStore;
|
|
|
|
m_CachedResults.Unlock();
|
|
|
|
if (NULL != m_FirstTimeWait)
|
|
{
|
|
m_FirstTimeWait->Set();
|
|
}
|
|
|
|
ResetRmonDuration();
|
|
m_Status = POLL_ENUM_STATUS;
|
|
m_Strobing = TRUE;
|
|
}
|
|
|
|
|
|
BOOL TopNTableProv::DeleteRmonConfiguration()
|
|
{
|
|
BOOL ret = FALSE;
|
|
BSTR classstr = SysAllocString(SETCONF_CLASS);
|
|
BSTR propstr = SysAllocString(CONFSTATUS_PROP);
|
|
VARIANT v;
|
|
VariantInit(&v);
|
|
v.vt = VT_BSTR;
|
|
v.bstrVal = SysAllocString(DEL_CONFSTATUS_PROP_VAL);
|
|
|
|
if ((NULL != classstr) && (NULL != propstr) && (NULL != v.bstrVal))
|
|
{
|
|
IEnumWbemClassObject *pEnum;
|
|
HRESULT result = m_wbemServ->CreateInstanceEnum(classstr, 0, NULL, &pEnum);
|
|
SysFreeString(classstr);
|
|
|
|
if ( (WBEM_NO_ERROR == result) && (WBEM_NO_ERROR == pEnum->Reset()) )
|
|
{
|
|
ret = TRUE;
|
|
ULONG returned;
|
|
IWbemClassObject* pObj = NULL;
|
|
|
|
result = pEnum->Next(-1,1, &pObj, &returned);
|
|
|
|
while ( (WBEM_NO_ERROR == result) && (1 == returned) )
|
|
{
|
|
VARIANT vIndex;
|
|
|
|
if (GetWBEMProperty(pObj, vIndex, CONFINDEX_PROP))
|
|
{
|
|
if (VT_I4 == vIndex.vt)
|
|
{
|
|
if ( (vIndex.lVal < (m_Confdata.GetIndex() + NUMBER_OF_RMON_INTERFACES))
|
|
&& (vIndex.lVal >= m_Confdata.GetIndex()) )
|
|
{
|
|
if (WBEM_NO_ERROR == pObj->Put(propstr, 0, &v, 0))
|
|
{
|
|
if (WBEM_NO_ERROR != m_wbemServ->PutInstance(pObj, 0, NULL,NULL))
|
|
{
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&vIndex);
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = FALSE;
|
|
}
|
|
|
|
pObj->Release();
|
|
pObj = NULL;
|
|
result = pEnum->Next(-1,1, &pObj, &returned);
|
|
}
|
|
|
|
pEnum->Release();
|
|
}
|
|
|
|
SysFreeString(propstr);
|
|
VariantClear(&v);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
LONG TopNTableProv::SetRmonConfiguration()
|
|
{
|
|
LONG ret = 0;
|
|
BSTR classstr = SysAllocString(CONF_CLASS);
|
|
|
|
if (NULL != classstr)
|
|
{
|
|
IWbemClassObject* pClass = NULL;
|
|
HRESULT result = m_wbemServ->GetObject(classstr, 0, NULL, &pClass, NULL);
|
|
SysFreeString(classstr);
|
|
|
|
if (WBEM_NO_ERROR == result)
|
|
{
|
|
IWbemClassObject* pInst = NULL;
|
|
|
|
if (WBEM_NO_ERROR == pClass->SpawnInstance(0, &pInst))
|
|
{
|
|
VARIANT v;
|
|
VariantInit(&v);
|
|
v.vt = VT_BSTR;
|
|
v.bstrVal = m_Confdata.GetStatsType();
|
|
|
|
if (!PutWBEMProperty(pInst, v, CONFRATE_PROP))
|
|
{
|
|
pInst->Release();
|
|
return 0;
|
|
}
|
|
|
|
v.bstrVal = SysAllocString(CONFOWNER_PROP_VAL);
|
|
|
|
if ((NULL == v.bstrVal) || !PutWBEMProperty(pInst, v, CONFOWNER_PROP))
|
|
{
|
|
pInst->Release();
|
|
SysFreeString(v.bstrVal);
|
|
return 0;
|
|
}
|
|
|
|
SysFreeString(v.bstrVal);
|
|
v.vt = VT_I4;
|
|
v.lVal = m_Confdata.GetInitialPeriodSecs();
|
|
|
|
if (!PutWBEMProperty(pInst, v, CONFDURATION_PROP))
|
|
{
|
|
pInst->Release();
|
|
return 0;
|
|
}
|
|
|
|
v.lVal = m_Confdata.GetNSize();
|
|
|
|
if (!PutWBEMProperty(pInst, v, CONFSIZE_PROP))
|
|
{
|
|
pInst->Release();
|
|
return 0;
|
|
}
|
|
|
|
UINT count = m_Confdata.GetIndex() + NUMBER_OF_RMON_INTERFACES;
|
|
UINT done = 1;
|
|
|
|
VARIANT vValidstatus;
|
|
VariantInit(&vValidstatus);
|
|
vValidstatus.vt = VT_BSTR;
|
|
vValidstatus.bstrVal = SysAllocString(VAL_CONFSTATUS_PROP_VAL);
|
|
VARIANT vCreatestatus;
|
|
VariantInit(&vCreatestatus);
|
|
vCreatestatus.vt = VT_BSTR;
|
|
vCreatestatus.bstrVal = SysAllocString(CRQ_CONFSTATUS_PROP_VAL);
|
|
|
|
if ((NULL == vCreatestatus.bstrVal) || (NULL == vValidstatus.bstrVal))
|
|
{
|
|
pInst->Release();
|
|
return 0;
|
|
}
|
|
|
|
ULONG y = 1;
|
|
|
|
for (UINT x = m_Confdata.GetIndex(); x < count; x++)
|
|
{
|
|
v.lVal = x;
|
|
|
|
if (!PutWBEMProperty(pInst, v, CONFINDEX_PROP))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
v.lVal = y++;
|
|
|
|
if (!PutWBEMProperty(pInst, v, CONFHOSTINDEX_PROP))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!PutWBEMProperty(pInst, vCreatestatus, CONFSTATUS_PROP))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
if (WBEM_NO_ERROR == m_wbemServ->PutInstance(pInst, 0, NULL, NULL))
|
|
{
|
|
if (PutWBEMProperty(pInst, vValidstatus, CONFSTATUS_PROP))
|
|
{
|
|
if (WBEM_NO_ERROR == m_wbemServ->PutInstance(pInst, 0, NULL, NULL))
|
|
{
|
|
done++;
|
|
}
|
|
}
|
|
|
|
VariantClear(&v);
|
|
v.vt = VT_I4;
|
|
}
|
|
}
|
|
|
|
VariantClear(&vValidstatus);
|
|
VariantClear(&vCreatestatus);
|
|
|
|
if (done == count)
|
|
{
|
|
ret = 1;
|
|
}
|
|
else if (done > 1)
|
|
{
|
|
ret = -1;
|
|
}
|
|
|
|
pInst->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
BOOL TopNTableProv::GetRmonConfData()
|
|
{
|
|
BSTR inststr = SysAllocString(CONFIGPATH);
|
|
BOOL ret = FALSE;
|
|
|
|
if (NULL != inststr)
|
|
{
|
|
IWbemClassObject *pConfInst;
|
|
HRESULT result = m_wbemServ->GetObject(inststr, 0, NULL, &pConfInst, NULL);
|
|
SysFreeString(inststr);
|
|
|
|
if (WBEM_NO_ERROR == result)
|
|
{
|
|
VARIANT v;
|
|
|
|
if (GetWBEMProperty(pConfInst, v, DATAPOLL_PROP))
|
|
{
|
|
if (VT_I4 == v.vt)
|
|
{
|
|
m_Confdata.SetPollPeriod(v.lVal);
|
|
|
|
if (GetWBEMProperty(pConfInst, v, FIRSTPOLL_PROP))
|
|
{
|
|
if (VT_I4 == v.vt)
|
|
{
|
|
m_Confdata.SetInitialPeriod(v.lVal);
|
|
|
|
if (GetWBEMProperty(pConfInst, v, DATAOFFSET_PROP))
|
|
{
|
|
if (VT_I4 == v.vt)
|
|
{
|
|
m_Confdata.SetDataOffset(v.lVal);
|
|
|
|
if (GetWBEMProperty(pConfInst, v, DATAOFFSET_PROP))
|
|
{
|
|
if (VT_I4 == v.vt)
|
|
{
|
|
m_Confdata.SetDataOffset(v.lVal);
|
|
|
|
if (GetWBEMProperty(pConfInst, v, RETRYPOLL_PROP))
|
|
{
|
|
if (VT_I4 == v.vt)
|
|
{
|
|
m_Confdata.SetDataRetry(v.lVal);
|
|
|
|
if (GetWBEMProperty(pConfInst, v, SIZEN_PROP))
|
|
{
|
|
if (VT_I4 == v.vt)
|
|
{
|
|
m_Confdata.SetNSize(v.lVal);
|
|
|
|
if (GetWBEMProperty(pConfInst, v, STATSTYPE_PROP))
|
|
{
|
|
if (VT_BSTR == v.vt)
|
|
{
|
|
m_Confdata.SetStatsType(v.bstrVal);
|
|
|
|
if (GetWBEMProperty(pConfInst, v, START_INDEX_PROP))
|
|
{
|
|
if (VT_I4 == v.vt)
|
|
{
|
|
m_Confdata.SetIndex(v.lVal);
|
|
ret = TRUE;
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&v);
|
|
}
|
|
}
|
|
|
|
pConfInst->Release();
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL TopNTableProv::GetWBEMProperty(IWbemClassObject* obj, VARIANT& val, wchar_t* prop)
|
|
{
|
|
return (WBEM_NO_ERROR == obj->Get(prop, 0, &val, NULL, NULL));
|
|
}
|
|
|
|
BOOL TopNTableProv::PutWBEMProperty(IWbemClassObject* obj, VARIANT& val, wchar_t* prop)
|
|
{
|
|
return (WBEM_NO_ERROR == obj->Put(prop, 0, &val, 0));
|
|
}
|
|
|
|
TopNTableProv::TopNTableProv(IWbemServices* wbemServ, ProviderStore& timer)
|
|
{
|
|
m_CacheAge = 0;
|
|
m_IsValid = FALSE;
|
|
m_wbemServ = wbemServ;
|
|
m_Status = CREATE_ENUM_STATUS;
|
|
m_timer = &timer;
|
|
m_Strobing = FALSE;
|
|
m_StrobeCount = 0;
|
|
m_FirstTimeWait = NULL;
|
|
|
|
|
|
if (NULL == m_wbemServ)
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
m_wbemServ->AddRef();
|
|
}
|
|
|
|
BSTR class_str = SysAllocString(PROVTOPN_CLASS);
|
|
|
|
if (NULL != class_str)
|
|
{
|
|
m_pObjProv = NULL;
|
|
HRESULT result = m_wbemServ->GetObject(class_str, 0, NULL, &m_pObjProv, NULL);
|
|
SysFreeString(class_str);
|
|
|
|
if (WBEM_NO_ERROR != result)
|
|
{
|
|
m_pObjProv = NULL;
|
|
}
|
|
else
|
|
{
|
|
if (InitializeRmon())
|
|
{
|
|
if (m_timer->RegisterProviderWithTimer(this))
|
|
{
|
|
m_FirstTimeWait = new SnmpEventObject;
|
|
m_IsValid = TRUE;
|
|
m_Strobing = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pObjProv = NULL;
|
|
}
|
|
}
|
|
|
|
TopNTableProv::~TopNTableProv()
|
|
{
|
|
if (m_IsValid)
|
|
{
|
|
m_timer->UnregisterProviderWithTimer(this);
|
|
}
|
|
|
|
if (NULL != m_pObjProv)
|
|
{
|
|
m_pObjProv->Release();
|
|
}
|
|
|
|
|
|
if (NULL != m_FirstTimeWait)
|
|
{
|
|
delete m_FirstTimeWait;
|
|
}
|
|
|
|
if (NULL != m_wbemServ)
|
|
{
|
|
m_wbemServ->Release();
|
|
}
|
|
|
|
m_CachedResults.Lock () ;
|
|
POSITION pos = m_CachedResults.m_pTopNCache->GetStartPosition();
|
|
|
|
while (NULL != pos)
|
|
{
|
|
IWbemClassObject *pObj;
|
|
ULONG keyval;
|
|
m_CachedResults.m_pTopNCache->GetNextAssoc(pos, keyval, pObj);
|
|
pObj->Release();
|
|
}
|
|
|
|
m_CachedResults.m_pTopNCache->RemoveAll () ;
|
|
m_CachedResults.Unlock () ;
|
|
}
|
|
|
|
|
|
void TopNTableProv::Strobe()
|
|
{
|
|
if (m_Strobing)
|
|
{
|
|
m_StrobeCount++;
|
|
|
|
switch (m_Status)
|
|
{
|
|
case CREATE_ENUM_STATUS:
|
|
{
|
|
if (m_StrobeCount ==
|
|
((m_Confdata.GetInitialPeriod() + m_Confdata.GetDataOffset()) / WINDOW_TIMER_STROBE_PERIOD))
|
|
{
|
|
m_Strobing = FALSE;
|
|
m_StrobeCount = 0;
|
|
Poll();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case POLL_ENUM_STATUS:
|
|
{
|
|
if (m_StrobeCount ==
|
|
((m_Confdata.GetPollPeriod() + m_Confdata.GetDataOffset()) / WINDOW_TIMER_STROBE_PERIOD))
|
|
{
|
|
m_Strobing = FALSE;
|
|
m_StrobeCount = 0;
|
|
Poll();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RETRY_ENUM_STATUS:
|
|
{
|
|
if (m_StrobeCount == (m_Confdata.GetDataRetry() / WINDOW_TIMER_STROBE_PERIOD))
|
|
{
|
|
m_Strobing = FALSE;
|
|
m_StrobeCount = 0;
|
|
RetryPoll();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
TopNCache *TopNTableProv::LockTopNCache ()
|
|
{
|
|
TopNCache *t_TopNCache = NULL ;
|
|
|
|
if (NULL != m_FirstTimeWait)
|
|
{
|
|
//wait twice the maximum initial time length or at least ten seconds...
|
|
DWORD timeout = ( m_Confdata.GetInitialPeriod()
|
|
+ m_Confdata.GetDataOffset()
|
|
+ m_Confdata.GetDataRetry() ) * 2;
|
|
|
|
if (timeout < 10000)
|
|
{
|
|
timeout = 10000;
|
|
}
|
|
|
|
WaitForSingleObject(m_FirstTimeWait->GetHandle(), timeout);
|
|
delete m_FirstTimeWait;
|
|
m_FirstTimeWait = NULL;
|
|
}
|
|
|
|
if ( m_CachedResults.Lock () )
|
|
{
|
|
return m_CachedResults.m_pTopNCache ;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
|
|
return t_TopNCache ;
|
|
}
|
|
|
|
void TopNTableProv::UnlockTopNCache ()
|
|
{
|
|
m_CachedResults.Unlock () ;
|
|
}
|
|
|
|
|
|
void TopNTableProv::ResetRmonDuration()
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
IEnumWbemClassObject *pEnum;
|
|
HRESULT result = m_wbemServ->CreateInstanceEnum(DURATIONCONF_CLASS, 0, NULL,&pEnum);
|
|
|
|
if ( (WBEM_NO_ERROR == result) && (WBEM_NO_ERROR == pEnum->Reset()) )
|
|
{
|
|
ret = TRUE;
|
|
ULONG returned;
|
|
IWbemClassObject* pObj = NULL;
|
|
VARIANT v;
|
|
VariantInit(&v);
|
|
v.vt = VT_I4;
|
|
v.lVal = m_Confdata.GetPollPeriodSecs();
|
|
|
|
result = pEnum->Next(-1,1, &pObj, &returned);
|
|
|
|
while ( (WBEM_NO_ERROR == result) && (1 == returned) )
|
|
{
|
|
VARIANT vIndex;
|
|
|
|
if (GetWBEMProperty(pObj, vIndex, CONFINDEX_PROP))
|
|
{
|
|
if (VT_I4 == vIndex.vt)
|
|
{
|
|
if ( (vIndex.lVal < (m_Confdata.GetIndex() + NUMBER_OF_RMON_INTERFACES))
|
|
&& (vIndex.lVal >= m_Confdata.GetIndex()) )
|
|
{
|
|
if (WBEM_NO_ERROR == pObj->Put(CONFDURATION_PROP, 0, &v, 0))
|
|
{
|
|
if (WBEM_NO_ERROR != m_wbemServ->PutInstance(pObj, 0, NULL,NULL))
|
|
{
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&vIndex);
|
|
ret = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = FALSE;
|
|
}
|
|
|
|
pObj->Release();
|
|
pObj = NULL;
|
|
result = pEnum->Next(-1,1, &pObj, &returned);
|
|
}
|
|
|
|
VariantClear(&v);
|
|
pEnum->Release();
|
|
}
|
|
|
|
//return ret;
|
|
}
|
|
|
|
|
|
BOOL TopNTableProv::AddHostProperties(IWbemClassObject* pDest, ULONG topNR, const CString& addrStr)
|
|
{
|
|
BOOL ret = FALSE;
|
|
|
|
//first get the config instance...
|
|
//build the path...
|
|
wchar_t buff[128]; //should be way big enough
|
|
wsprintf(buff, L"%s%lc%s%lc%lu", CONF_CLASS, DOT_CHAR, CONFINDEX_PROP,EQUALS_CHAR, topNR);
|
|
IWbemClassObject *pConfInst;
|
|
HRESULT result = m_wbemServ->GetObject(buff, 0, NULL,&pConfInst, NULL);
|
|
|
|
if (WBEM_NO_ERROR != result)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
VARIANT v;
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, CONFHOSTINDEX_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
pConfInst->Release();
|
|
|
|
if (v.vt != VT_I4)
|
|
{
|
|
VariantClear(&v);
|
|
return FALSE;
|
|
}
|
|
|
|
//now get the hostTable entry...
|
|
//build the path again...
|
|
wsprintf(buff, L"%s%lc%s%lc%lc%s%lc%lc%s%lc%lu", HOST_CLASS, DOT_CHAR, HOSTADDRESS_PROP,
|
|
EQUALS_CHAR, QUOTE_CHAR, addrStr, QUOTE_CHAR,
|
|
COMMA_CHAR, HOSTINDEX_PROP, EQUALS_CHAR, v.lVal);
|
|
|
|
result = m_wbemServ->GetObject(buff, 0, NULL,&pConfInst, NULL);
|
|
|
|
if (WBEM_NO_ERROR != result)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//now copy all the properties...
|
|
if (!PutWBEMProperty(pDest, v, HOSTINDEX_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, HOSTOUTPKT_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(pDest, v, HOSTOUTPKT_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, HOSTOUTOCT_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(pDest, v, HOSTOUTOCT_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, HOSTOUTMCAST_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(pDest, v, HOSTOUTMCAST_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, HOSTOUTERROR_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(pDest, v, HOSTOUTERROR_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, HOSTOUTBCAST_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(pDest, v, HOSTOUTBCAST_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, HOSTINOCT_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(pDest, v, HOSTINOCT_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
if (!GetWBEMProperty(pConfInst, v, HOSTINPKT_PROP))
|
|
{
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
if ((v.vt != VT_I4) || !PutWBEMProperty(pDest, v, HOSTINPKT_PROP))
|
|
{
|
|
VariantClear(&v);
|
|
pConfInst->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
VariantClear(&v);
|
|
|
|
//succeeded in getting and setting all properties!
|
|
pConfInst->Release();
|
|
ret = TRUE;
|
|
|
|
return ret;
|
|
}
|