//*************************************************************************** // // THRESHLD.CPP // // Module: HEALTHMON SERVER AGENT // // Purpose: CThreshold class to do thresholding on a CDatapoint class. // The CDatapoint class contains the WMI instance, and the CThreshold // class says what ptoperty to threshold against, and how. // // Copyright (c)1999 Microsoft Corporation, All Rights Reserved // //*************************************************************************** #include #include #include "threshld.h" #include "datacltr.h" #include "system.h" extern CSystem* g_pSystem; extern CSystem* g_pStartupSystem; BOOL CThreshold::mg_bEnglishCompare = TRUE; //STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC void CThreshold::ThresholdTerminationCleanup(void) { if (g_pThresholdEventSink != NULL) { g_pThresholdEventSink->Release(); g_pThresholdEventSink = NULL; } #ifdef SAVE if (g_pThresholdInstanceEventSink != NULL) { g_pThresholdInstanceEventSink->Release(); g_pThresholdInstanceEventSink = NULL; } #endif } //STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC void CThreshold::GetLocal(void) { LCID lcID = PRIMARYLANGID(GetSystemDefaultLCID()); if (lcID != 0 && lcID == 0x00000009) { mg_bEnglishCompare = TRUE; } else { mg_bEnglishCompare = FALSE; } } ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CThreshold::CThreshold() { MY_OUTPUT(L"ENTER ***** CThreshold...", 4); Init(); m_hmStatusType = HMSTATUS_THRESHOLD; m_bValidLoad = FALSE; MY_OUTPUT(L"EXIT ***** CThreshold...", 4); } CThreshold::~CThreshold() { MY_OUTPUT(L"ENTER ***** ~CThreshold...", 4); g_pStartupSystem->RemovePointerFromMasterList(this); Cleanup(FALSE); if (m_szGUID) { delete [] m_szGUID; m_szGUID = NULL; } m_bValidLoad = FALSE; MY_OUTPUT(L"EXIT ***** ~CThreshold...", 4); } // // Load a single Threshold // HRESULT CThreshold::LoadInstanceFromMOF(IWbemClassObject* pObj, CDataCollector *pParentDC, LPTSTR pszParentObjPath, BOOL bModifyPass/*FALSE*/) { long lTemp; HRESULT hRes = S_OK; BOOL bRetValue = TRUE; MY_OUTPUT(L"ENTER ***** CThreshold::LoadInstanceFromMOF...", 4); Cleanup(bModifyPass); m_bValidLoad = TRUE; if (bModifyPass == FALSE) { // This is the first initial read in of this // Get the GUID property // If this fails we will actually not go through with the creation of this object. if (m_szGUID) { delete [] m_szGUID; m_szGUID = NULL; } hRes = GetStrProperty(pObj, L"GUID", &m_szGUID); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; m_szParentObjPath = new TCHAR[wcslen(pszParentObjPath)+1]; MY_ASSERT(m_szParentObjPath); if (!m_szParentObjPath) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(m_szParentObjPath, pszParentObjPath); m_pParentDC = pParentDC; hRes = g_pStartupSystem->AddPointerToMasterList(this); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; } hRes = GetStrProperty(pObj, L"Name", &m_szName); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = GetStrProperty(pObj, L"Description", &m_szDescription); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = GetStrProperty(pObj, L"PropertyName", &m_szPropertyName); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; if (!wcscmp(m_szPropertyName, L"")) { delete [] m_szPropertyName; m_szPropertyName = new TCHAR[wcslen(L"CollectionErrorCode")+1]; MY_ASSERT(m_szPropertyName); if (!m_szPropertyName) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(m_szPropertyName, L"CollectionErrorCode"); } bRetValue = GetUint32Property(pObj, L"UseFlag", &lTemp); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; if (lTemp == 0) { m_bUseAverage = FALSE; m_bUseDifference = FALSE; } else if (lTemp == 1) { m_bUseAverage = TRUE; m_bUseDifference = FALSE; } else if (lTemp == 2) { m_bUseAverage = FALSE; m_bUseDifference = TRUE; } else { m_bUseAverage = FALSE; m_bUseDifference = FALSE; MY_ASSERT(FALSE); } // hRes = GetBoolProperty(pObj, L"UseSum", &m_bUseSum); // MY_HRESASSERT(hRes); m_bUseSum = FALSE; //[values {"<",">","=","!=",">=","<=","contains","!contains","always"}] hRes = GetUint32Property(pObj, L"TestCondition", &m_lTestCondition); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = GetStrProperty(pObj, L"CompareValue", &m_szCompareValue); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; m_lCompareValue = wcstol(m_szCompareValue, NULL, 10); m_ulCompareValue = wcstoul(m_szCompareValue, NULL, 10); m_fCompareValue = (float) wcstod(m_szCompareValue, NULL); m_dCompareValue = wcstod(m_szCompareValue, NULL); m_i64CompareValue = _wtoi64(m_szCompareValue); m_ui64CompareValue = 0; ReadUI64(m_szCompareValue, m_ui64CompareValue); hRes = GetUint32Property(pObj, L"ThresholdDuration", &m_lThresholdDuration); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; //[values {"CRITICAL","WARNING","INFO","RESET"}] hRes = GetUint32Property(pObj, L"State", &m_lViolationToState); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = GetStrProperty(pObj, L"CreationDate", &m_szCreationDate); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = GetStrProperty(pObj, L"LastUpdate", &m_szLastUpdate); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = GetBoolProperty(pObj, L"Enabled", &m_bEnabled); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; if (bModifyPass == FALSE) { if (m_bEnabled==FALSE || m_pParentDC->m_bEnabled==FALSE || m_pParentDC->m_bParentEnabled==FALSE) { if (m_pParentDC->m_bEnabled==FALSE || m_pParentDC->m_bParentEnabled==FALSE) m_bParentEnabled = FALSE; // Since our parent is disabled, we will not be able to get into // our OnAgentInterval function and send the disabled status later. SetCurrState(HM_DISABLED); FireEvent(TRUE); } } else { if (m_pParentDC->m_deType==HM_EQDE) { if (m_bEnabled==FALSE || m_pParentDC->m_bEnabled==FALSE || m_pParentDC->m_bParentEnabled==FALSE) { SetCurrState(HM_DISABLED); FireEvent(FALSE); } } } m_bValidLoad = TRUE; MY_OUTPUT(L"EXIT ***** CThreshold::LoadInstanceFromMOF...", 4); return S_OK; error: MY_ASSERT(FALSE); Cleanup(FALSE); m_bValidLoad = FALSE; return hRes; } BOOL CThreshold::SkipClean(void) { IRSSTRUCT *pirs; int i, iSize; m_lNumberChanges = 0; // // Clear things before we start // m_lPrevState = m_lCurrState; iSize = m_irsList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(ilPrevState = m_lCurrState; pirs->lCurrState = m_lCurrState; pirs->unknownReason = 0; } return TRUE; } // // Evaluate this threshold against the property just collected // BOOL CThreshold::OnAgentInterval(ACTUALINSTLIST *actualInstList, PNSTRUCT *ppn, BOOL bRequireReset) { long state; INSTSTRUCT *pinst; IRSSTRUCT *pirs; union hm_datatypes delta; int i, iSize; // // Don't do anything if we are not loaded correctly. // if (m_bValidLoad == FALSE) return FALSE; m_lNumberChanges = 0; // // Don't do anything if we are already in the state we need to be in. // DISABLED, SCHEDULEDOUT // if (((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState==HM_DISABLED) || (m_bParentScheduledOut==TRUE && m_lCurrState==HM_SCHEDULEDOUT)) { // The DISABLED and SCHEDULEDOUT states override the UNKNWON. We may be transitioning. if (((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState!=HM_DISABLED) || (m_bParentScheduledOut==TRUE && m_lCurrState!=HM_SCHEDULEDOUT)) { // The DISABLED state overrides SCHEDULEDOUT. We may be transitioning. if (((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState!=HM_DISABLED)) { } else { if (m_lPrevState != m_lCurrState) { m_lPrevState = m_lCurrState; iSize = m_irsList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(ilPrevState = m_lCurrState; pirs->lCurrState = m_lCurrState; pirs->unknownReason = 0; } } return TRUE; } } else { if (m_lPrevState != m_lCurrState) { m_lPrevState = m_lCurrState; iSize = m_irsList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(ilPrevState = m_lCurrState; pirs->lCurrState = m_lCurrState; pirs->unknownReason = 0; } } return TRUE; } } // // Clear things before we start // m_lPrevState = m_lCurrState; iSize = m_irsList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(im_deType!=HM_EQDE) { pirs->lPrevState = pirs->lCurrState; } else { pirs->lPrevState = m_lCurrState; pirs->lCurrState = m_lCurrState; } pirs->unknownReason = 0; } // // This is where we are transitioning into the DISABLED State. // if (m_bEnabled==FALSE || m_bParentEnabled==FALSE) { SetCurrState(HM_DISABLED); } else if (m_bParentScheduledOut==TRUE) { SetCurrState(HM_SCHEDULEDOUT); } else { if (bRequireReset && (m_lCurrState==HM_WARNING || m_lCurrState==HM_CRITICAL)) return TRUE; int x = ppn->instList.size(); int y = m_irsList.size(); // Check for something that should not be happening if (x != y) { MY_OUTPUT(L"BAD BAD BAD - Vector sizes do not match!!!", 2); MY_ASSERT(FALSE); return TRUE; } // // For each instance, evaluate what the current state is. // MY_ASSERT(ppn->instList.size() == m_irsList.size()); iSize = ppn->instList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iinstList.size()); pinst = &ppn->instList[i]; MY_ASSERT(itype == CIM_REAL32) { if (pirs->fPrevValue == MAX_FLOAT) { if (m_bUseAverage) pirs->fPrevValue = pinst->avgValue.fValue; else pirs->fPrevValue = pinst->currValue.fValue; } } else if (ppn->type == CIM_REAL64) { if (pirs->dPrevValue == MAX_DOUBLE) { if (m_bUseAverage) pirs->dPrevValue = pinst->avgValue.dValue; else pirs->dPrevValue = pinst->currValue.dValue; } } else if (ppn->type == CIM_SINT64) { if (pirs->i64PrevValue == MAX_I64) { if (m_bUseAverage) pirs->i64PrevValue = pinst->avgValue.i64Value; else pirs->i64PrevValue = pinst->currValue.i64Value; } } else if (ppn->type == CIM_UINT64) { if (pirs->ui64PrevValue == MAX_UI64) { if (m_bUseAverage) pirs->ui64PrevValue = pinst->avgValue.ui64Value; else pirs->ui64PrevValue = pinst->currValue.ui64Value; } } else if (ppn->type == CIM_UINT32) { if (pirs->ulPrevValue == MAX_ULONG) { if (m_bUseAverage) pirs->ulPrevValue = pinst->avgValue.ulValue; else pirs->ulPrevValue = pinst->currValue.ulValue; } } else { if (pirs->lPrevValue == MAX_LONG) { if (m_bUseAverage) pirs->lPrevValue = pinst->avgValue.lValue; else pirs->lPrevValue = pinst->currValue.lValue; } } if (ppn->type == CIM_REAL32) { pirs->fPrevPrevValue = pirs->fPrevValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevPrevValue = pirs->dPrevValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevPrevValue = pirs->i64PrevValue; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevPrevValue = pirs->ui64PrevValue; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevPrevValue = pirs->ulPrevValue; } else { pirs->lPrevPrevValue = pirs->lPrevValue; } if ((pirs->lCurrState!=HM_CRITICAL && pirs->lCurrState!=HM_WARNING && pirs->lCurrState!=HM_RESET) || m_lViolationToState!=pirs->lCurrState) { if (pirs->lCurrState!=HM_GOOD) pirs->lCurrState = HM_GOOD; if (m_bUseDifference) { if (m_bUseAverage) { if (ppn->type == CIM_REAL32) { if (pinst->avgValue.fValue < pirs->fPrevValue) delta.fValue = pirs->fPrevValue-pinst->avgValue.fValue; else delta.fValue = pinst->avgValue.fValue-pirs->fPrevValue; } else if (ppn->type == CIM_REAL64) { if (pinst->avgValue.dValue < pirs->dPrevValue) delta.dValue = pirs->dPrevValue-pinst->avgValue.dValue; else delta.dValue = pinst->avgValue.dValue-pirs->dPrevValue; } else if (ppn->type == CIM_SINT64) { if (pinst->avgValue.i64Value < pirs->i64PrevValue) delta.i64Value = pirs->i64PrevValue-pinst->avgValue.i64Value; else delta.i64Value = pinst->avgValue.i64Value-pirs->i64PrevValue; } else if (ppn->type == CIM_UINT64) { if (pinst->avgValue.ui64Value < pirs->ui64PrevValue) delta.ui64Value = pirs->ui64PrevValue-pinst->avgValue.ui64Value; else delta.ui64Value = pinst->avgValue.ui64Value-pirs->ui64PrevValue; } else if (ppn->type == CIM_UINT32) { if (pinst->avgValue.ulValue < pirs->ulPrevValue) delta.ulValue = pirs->ulPrevValue-pinst->avgValue.ulValue; else delta.ulValue = pinst->avgValue.ulValue-pirs->ulPrevValue; } else { if (pinst->avgValue.lValue < pirs->lPrevValue) delta.lValue = pirs->lPrevValue-pinst->avgValue.lValue; else delta.lValue = pinst->avgValue.lValue-pirs->lPrevValue; } CrossTest(ppn, pirs, L"", delta, pinst); if (ppn->type == CIM_REAL32) { pirs->fPrevValue = pinst->avgValue.fValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevValue = pinst->avgValue.dValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevValue = pinst->avgValue.i64Value; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevValue = pinst->avgValue.ui64Value; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevValue = pinst->avgValue.ulValue; } else { pirs->lPrevValue = pinst->avgValue.lValue; } } else { if (ppn->type == CIM_REAL32) { if (pinst->currValue.fValue < pirs->fPrevValue) delta.fValue = pirs->fPrevValue-pinst->currValue.fValue; else delta.fValue = pinst->currValue.fValue-pirs->fPrevValue; } else if (ppn->type == CIM_REAL64) { if (pinst->currValue.dValue < pirs->dPrevValue) delta.dValue = pirs->dPrevValue-pinst->currValue.dValue; else delta.dValue = pinst->currValue.dValue-pirs->dPrevValue; } else if (ppn->type == CIM_SINT64) { if (pinst->currValue.i64Value < pirs->i64PrevValue) delta.i64Value = pirs->i64PrevValue-pinst->currValue.i64Value; else delta.i64Value = pinst->currValue.i64Value-pirs->i64PrevValue; } else if (ppn->type == CIM_UINT64) { if (pinst->currValue.ui64Value < pirs->ui64PrevValue) delta.ui64Value = pirs->ui64PrevValue-pinst->currValue.ui64Value; else delta.ui64Value = pinst->currValue.ui64Value-pirs->ui64PrevValue; } else if (ppn->type == CIM_UINT32) { if (pinst->currValue.ulValue < pirs->ulPrevValue) delta.ulValue = pirs->ulPrevValue-pinst->currValue.ulValue; else delta.ulValue = pinst->currValue.ulValue-pirs->ulPrevValue; } else { if (pinst->currValue.lValue < pirs->lPrevValue) delta.lValue = pirs->lPrevValue-pinst->currValue.lValue; else delta.lValue = pinst->currValue.lValue-pirs->lPrevValue; } CrossTest(ppn, pirs, L"", delta, pinst); if (ppn->type == CIM_REAL32) { pirs->fPrevValue = pinst->currValue.fValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevValue = pinst->currValue.dValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevValue = pinst->currValue.i64Value; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevValue = pinst->currValue.ui64Value; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevValue = pinst->currValue.ulValue; } else { pirs->lPrevValue = pinst->currValue.lValue; } } } else { if (m_bUseAverage) { CrossTest(ppn, pirs, L"", pinst->avgValue, pinst); if (ppn->type == CIM_REAL32) { pirs->fPrevValue = pinst->avgValue.fValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevValue = pinst->avgValue.dValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevValue = pinst->avgValue.i64Value; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevValue = pinst->avgValue.ui64Value; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevValue = pinst->avgValue.ulValue; } else { pirs->lPrevValue = pinst->avgValue.lValue; } } else { CrossTest(ppn, pirs, pinst->szCurrValue, pinst->currValue, pinst); } } } else { if (m_bUseDifference) { if (m_bUseAverage) { if (ppn->type == CIM_REAL32) { if (pinst->avgValue.fValue < pirs->fPrevValue) delta.fValue = pirs->fPrevValue-pinst->avgValue.fValue; else delta.fValue = pinst->avgValue.fValue-pirs->fPrevValue; } else if (ppn->type == CIM_REAL64) { if (pinst->avgValue.dValue < pirs->dPrevValue) delta.dValue = pirs->dPrevValue-pinst->avgValue.dValue; else delta.dValue = pinst->avgValue.dValue-pirs->dPrevValue; } else if (ppn->type == CIM_SINT64) { if (pinst->avgValue.i64Value < pirs->i64PrevValue) delta.i64Value = pirs->i64PrevValue-pinst->avgValue.i64Value; else delta.i64Value = pinst->avgValue.i64Value-pirs->i64PrevValue; } else if (ppn->type == CIM_UINT64) { if (pinst->avgValue.ui64Value < pirs->ui64PrevValue) delta.ui64Value = pirs->ui64PrevValue-pinst->avgValue.ui64Value; else delta.ui64Value = pinst->avgValue.ui64Value-pirs->ui64PrevValue; } else if (ppn->type == CIM_UINT32) { if (pinst->avgValue.ulValue < pirs->ulPrevValue) delta.ulValue = pirs->ulPrevValue-pinst->avgValue.ulValue; else delta.ulValue = pinst->avgValue.ulValue-pirs->ulPrevValue; } else { if (pinst->avgValue.lValue < pirs->lPrevValue) delta.lValue = pirs->lPrevValue-pinst->avgValue.lValue; else delta.lValue = pinst->avgValue.lValue-pirs->lPrevValue; } RearmTest(ppn, pirs, L"", delta, pinst); if (ppn->type == CIM_REAL32) { pirs->fPrevValue = pinst->avgValue.fValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevValue = pinst->avgValue.dValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevValue = pinst->avgValue.i64Value; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevValue = pinst->avgValue.ui64Value; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevValue = pinst->avgValue.ulValue; } else { pirs->lPrevValue = pinst->avgValue.lValue; } } else { if (ppn->type == CIM_REAL32) { if (pinst->currValue.fValue < pirs->fPrevValue) delta.fValue = pirs->fPrevValue-pinst->currValue.fValue; else delta.fValue = pinst->currValue.fValue-pirs->fPrevValue; } else if (ppn->type == CIM_REAL64) { if (pinst->currValue.dValue < pirs->dPrevValue) delta.dValue = pirs->dPrevValue-pinst->currValue.dValue; else delta.dValue = pinst->currValue.dValue-pirs->dPrevValue; } else if (ppn->type == CIM_SINT64) { if (pinst->currValue.i64Value < pirs->i64PrevValue) delta.i64Value = pirs->i64PrevValue-pinst->currValue.i64Value; else delta.i64Value = pinst->currValue.i64Value-pirs->i64PrevValue; } else if (ppn->type == CIM_UINT64) { if (pinst->currValue.ui64Value < pirs->ui64PrevValue) delta.ui64Value = pirs->ui64PrevValue-pinst->currValue.ui64Value; else delta.ui64Value = pinst->currValue.ui64Value-pirs->ui64PrevValue; } else if (ppn->type == CIM_UINT32) { if (pinst->currValue.ulValue < pirs->ulPrevValue) delta.ulValue = pirs->ulPrevValue-pinst->currValue.ulValue; else delta.ulValue = pinst->currValue.ulValue-pirs->ulPrevValue; } else { if (pinst->currValue.lValue < pirs->lPrevValue) delta.lValue = pirs->lPrevValue-pinst->currValue.lValue; else delta.lValue = pinst->currValue.lValue-pirs->lPrevValue; } RearmTest(ppn, pirs, L"", delta, pinst); if (ppn->type == CIM_REAL32) { pirs->fPrevValue = pinst->currValue.fValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevValue = pinst->currValue.dValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevValue = pinst->currValue.i64Value; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevValue = pinst->currValue.ui64Value; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevValue = pinst->currValue.ulValue; } else { pirs->lPrevValue = pinst->currValue.lValue; } } } else { if (m_bUseAverage) { RearmTest(ppn, pirs, L"", pinst->avgValue, pinst); if (ppn->type == CIM_REAL32) { pirs->fPrevValue = pinst->avgValue.fValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevValue = pinst->avgValue.dValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevValue = pinst->avgValue.i64Value; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevValue = pinst->avgValue.ui64Value; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevValue = pinst->avgValue.ulValue; } else { pirs->lPrevValue = pinst->avgValue.lValue; } } else { RearmTest(ppn, pirs, pinst->szCurrValue, pinst->currValue, pinst); } } } } // // Set the state to the worst of all instances // m_lNumberNormals = 0; m_lNumberWarnings = 0; m_lNumberCriticals = 0; m_lNumberChanges = 0; m_lCurrState = -1; iSize = m_irsList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(ilCurrState; if (state > m_lCurrState) { m_lCurrState = state; } if (state == HM_GOOD) { m_lNumberNormals++; } if (state == HM_WARNING) { m_lNumberWarnings++; } if (state == HM_CRITICAL) { m_lNumberCriticals++; } if (pirs->lPrevState != pirs->lCurrState) { //MY_OUTPUT2(L"CHANGE state=%d", state, 4); m_lNumberChanges++; } } // Maybe we don't have anything underneith if (m_lCurrState == -1) { m_lCurrState = HM_GOOD; if (m_lPrevState != m_lCurrState) { m_lNumberChanges = 1; } } } // // the INFO state is not a state that we can transition to, but we just send out the message. // if (m_lCurrState == HM_INFO) { m_lCurrState = HM_GOOD; } else { FireEvent(FALSE); } return TRUE; } // // If there has been a change in the state then send an event // BOOL CThreshold::FireEvent(BOOL bForce) { BOOL bRetValue = TRUE; IWbemClassObject* pInstance = NULL; HRESULT hRes; IRSSTRUCT *pirs; int i, iSize; MY_OUTPUT(L"ENTER ***** CThreshold::FireEvent...", 2); // A quick test to see if anything has really changed! // Proceed if there have been changes if (m_lViolationToState==HM_RESET && bForce==FALSE && m_lNumberChanges!=0) { if (m_lPrevState==HM_DISABLED || m_lPrevState==HM_SCHEDULEDOUT || m_lCurrState==HM_DISABLED || m_lCurrState==HM_SCHEDULEDOUT) { } else { m_lPrevState = m_lCurrState; iSize = m_irsList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(ilPrevState = m_lCurrState; pirs->lCurrState = m_lCurrState; pirs->unknownReason = 0; } m_lNumberChanges = 0; return TRUE; } } else { if (bForce || (m_lNumberChanges!=0 && m_lPrevState!=m_lCurrState)) { } else { return FALSE; } } // Don't send if no-one is listening! if (g_pThresholdEventSink == NULL) { return bRetValue; } MY_OUTPUT2(L"EVENT: Threshold State Change=%d", m_lCurrState, 4); // Update time if there has been a change wcscpy(m_szDTTime, m_szDTCurrTime); wcscpy(m_szTime, m_szCurrTime); hRes = GetHMThresholdStatusInstance(&pInstance, TRUE); if (FAILED(hRes)) { MY_HRESASSERT(hRes); MY_OUTPUT(L"failed to get instance!", 1); return FALSE; } else { // // Place Extrinstic event in vector for sending at end of interval. // All get sent at once. // mg_TEventList.push_back(pInstance); } MY_OUTPUT(L"EXIT ***** CThreshold::FireEvent...", 2); return bRetValue; } BOOL CThreshold::CrossTest(PNSTRUCT *ppn, IRSSTRUCT *pirs, LPTSTR szTestValue, union hm_datatypes testValue, INSTSTRUCT *pinst) { HRESULT hRes = S_OK; TCHAR szTemp[128] = {0}; BOOL bViolated = FALSE; int i; BOOL bAllDigits; LPTSTR pszCompareValueUpper = NULL; LPTSTR pszTestValueUpper = NULL; int rc = 0; char buffer[50]; MY_OUTPUT(L"ENTER ***** CrossTest...", 1); if (pinst->bNull) { // pirs->lCurrState = HM_CRITICAL; // pirs->unknownReason = HMRES_NULLVALUE; pirs->lCrossCountTry = 0; return TRUE; } if (m_lTestCondition == HM_LT) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)<0) { bViolated = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)<0) { bViolated = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bViolated = (i64Value < m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)<0) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { bViolated = (testValue.fValue < m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bViolated = (testValue.dValue < m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bViolated = (testValue.i64Value < m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bViolated = (testValue.ui64Value < m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bViolated = (testValue.ulValue < m_ulCompareValue); } else { // Must be an integer type bViolated = (testValue.lValue < m_lCompareValue); } } else if (m_lTestCondition == HM_GT) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)>0) { bViolated = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)>0) { bViolated = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bViolated = (i64Value > m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)>0) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { bViolated = (testValue.fValue > m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bViolated = (testValue.dValue > m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bViolated = (testValue.i64Value > m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bViolated = (testValue.ui64Value > m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bViolated = (testValue.ulValue > m_ulCompareValue); } else { // Must be an integer type bViolated = (testValue.lValue > m_lCompareValue); } } else if (m_lTestCondition == HM_EQ) { if (ppn->type == CIM_STRING) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)==0) { bViolated = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)==0) { bViolated = TRUE; } } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)==0) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { bViolated = (testValue.fValue == m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bViolated = (testValue.dValue == m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bViolated = (testValue.i64Value == m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bViolated = (testValue.ui64Value == m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bViolated = (testValue.ulValue == m_ulCompareValue); } else { // Must be an integer type bViolated = (testValue.lValue == m_lCompareValue); } } else if (m_lTestCondition == HM_NE) { if (ppn->type == CIM_STRING) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)!=0) { bViolated = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)!=0) { bViolated = TRUE; } } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)!=0) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { bViolated = (testValue.fValue != m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bViolated = (testValue.dValue != m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bViolated = (testValue.i64Value != m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bViolated = (testValue.ui64Value != m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bViolated = (testValue.ulValue != m_ulCompareValue); } else { // Must be an integer type bViolated = (testValue.lValue != m_lCompareValue); } } else if (m_lTestCondition == HM_GE) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)>=0) { bViolated = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)>=0) { bViolated = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bViolated = (i64Value >= m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)>=0) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { bViolated = (testValue.fValue >= m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bViolated = (testValue.dValue >= m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bViolated = (testValue.i64Value >= m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bViolated = (testValue.ui64Value >= m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { // Must be an integer type bViolated = (testValue.ulValue >= m_ulCompareValue); } else { // Must be an integer type bViolated = (testValue.lValue >= m_lCompareValue); } } else if (m_lTestCondition == HM_LE) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)<=0) { bViolated = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)<=0) { bViolated = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bViolated = (i64Value <= m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)<=0) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { bViolated = (testValue.fValue <= m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bViolated = (testValue.dValue <= m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bViolated = (testValue.i64Value <= m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bViolated = (testValue.ui64Value <= m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bViolated = (testValue.ulValue <= m_ulCompareValue); } else { // Must be an integer type bViolated = (testValue.lValue <= m_lCompareValue); } } else if (m_lTestCondition == HM_CONTAINS) { if (ppn->type == CIM_STRING) { pszCompareValueUpper = _wcsdup(m_szCompareValue); MY_ASSERT(pszCompareValueUpper); if (!pszCompareValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszCompareValueUpper); pszTestValueUpper = _wcsdup(szTestValue); MY_ASSERT(pszTestValueUpper); if (!pszTestValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszTestValueUpper); if (wcsstr(pszTestValueUpper, pszCompareValueUpper)) { bViolated = TRUE; } free(pszCompareValueUpper); pszCompareValueUpper = NULL; free(pszTestValueUpper); pszTestValueUpper = NULL; } else if (ppn->type == CIM_DATETIME) { if (wcsstr(szTestValue, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { _gcvt((double)testValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL64) { _gcvt(testValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_SINT64) { _i64tow(testValue.i64Value, szTemp, 10 ); if (wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_UINT64) { _ui64tow((int)testValue.ui64Value, szTemp, 10); if (wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_UINT32) { _ultow(testValue.ulValue, szTemp, 10); if (wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else { // Must be an integer type _ltow(testValue.lValue, szTemp, 10); if (wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } } else if (m_lTestCondition == HM_NOTCONTAINS) { if (ppn->type == CIM_STRING) { pszCompareValueUpper = _wcsdup(m_szCompareValue); MY_ASSERT(pszCompareValueUpper); if (!pszCompareValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszCompareValueUpper); pszTestValueUpper = _wcsdup(szTestValue); MY_ASSERT(pszTestValueUpper); if (!pszTestValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszTestValueUpper); if (!wcsstr(pszTestValueUpper, pszCompareValueUpper)) { bViolated = TRUE; } free(pszCompareValueUpper); pszCompareValueUpper = NULL; free(pszTestValueUpper); pszTestValueUpper = NULL; } else if (ppn->type == CIM_DATETIME) { if (!wcsstr(szTestValue, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL32) { _gcvt((double)testValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (!wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_REAL64) { _gcvt(testValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (!wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_SINT64) { _i64tow(testValue.i64Value, szTemp, 10 ); if (!wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_UINT64) { _ui64tow((int)testValue.ui64Value, szTemp, 10); if (!wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else if (ppn->type == CIM_UINT32) { _ultow(testValue.ulValue, szTemp, 10); if (!wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } else { // Must be an integer type _ltow(testValue.lValue, szTemp, 10); if (!wcsstr(szTemp, m_szCompareValue)) { bViolated = TRUE; } } } else if (m_lTestCondition == HM_ALWAYS) { bViolated = TRUE; } else { MY_ASSERT(FALSE); } // // Also see if the duration test has been met // if (bViolated) { if (m_lThresholdDuration==0 || (m_lThresholdDuration <= pirs->lCrossCountTry)) { pirs->lCurrState = m_lViolationToState; } pirs->lCrossCountTry++; } else { pirs->lCrossCountTry = 0; } MY_OUTPUT(L"EXIT ***** CrossTest...", 1); return TRUE; error: MY_ASSERT(FALSE); if (pszCompareValueUpper) free(pszCompareValueUpper); if (pszTestValueUpper) free(pszTestValueUpper); Cleanup(FALSE); m_bValidLoad = FALSE; return FALSE; } BOOL CThreshold::RearmTest(PNSTRUCT *ppn, IRSSTRUCT *pirs, LPTSTR szTestValue, union hm_datatypes testValue, INSTSTRUCT *pinst) { HRESULT hRes = S_OK; TCHAR szTemp[128] = {0}; BOOL bReset = FALSE; int i; BOOL bAllDigits; LPTSTR pszCompareValueUpper = NULL; LPTSTR pszTestValueUpper = NULL; int rc = 0; char buffer[50]; MY_OUTPUT(L"ENTER ***** RearmTest...", 1); //XXXIf too much of this code look duplicated from the Crosstest finction, try to //combine the two, and pass in what need!!! if (pinst->bNull) { // pirs->lCurrState = HM_CRITICAL; // pirs->unknownReason = HMRES_NULLVALUE; pirs->lCurrState = HM_GOOD; pirs->lCrossCountTry = 0; return TRUE; } if (m_lTestCondition == HM_LT) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)>=0) { bReset = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)>=0) { bReset = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bReset = (i64Value >= m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)>=0) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { bReset = (testValue.fValue >= m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bReset = (testValue.dValue >= m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bReset = (testValue.i64Value >= m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bReset = (testValue.ui64Value >= m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bReset = (testValue.ulValue >= m_ulCompareValue); } else { // Must be an integer type bReset = (testValue.lValue >= m_lCompareValue); } } else if (m_lTestCondition == HM_GT) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)<=0) { bReset = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)<=0) { bReset = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bReset = (i64Value <= m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)<=0) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { bReset = (testValue.fValue <= m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bReset = (testValue.dValue <= m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bReset = (testValue.i64Value <= m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bReset = (testValue.ui64Value <= m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bReset = (testValue.ulValue <= m_ulCompareValue); } else { // Must be an integer type bReset = (testValue.lValue <= m_lCompareValue); } } else if (m_lTestCondition == HM_EQ) { if (ppn->type == CIM_STRING) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)!=0) { bReset = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)!=0) { bReset = TRUE; } } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)==0) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { bReset = (testValue.fValue != m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bReset = (testValue.dValue != m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bReset = (testValue.i64Value != m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bReset = (testValue.ui64Value != m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bReset = (testValue.ulValue != m_ulCompareValue); } else { bReset = (testValue.lValue != m_lCompareValue); } } else if (m_lTestCondition == HM_NE) { if (ppn->type == CIM_STRING) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)==0) { bReset = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)==0) { bReset = TRUE; } } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)==0) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { bReset = (testValue.fValue == m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bReset = (testValue.dValue == m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bReset = (testValue.i64Value == m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bReset = (testValue.ui64Value == m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bReset = (testValue.ulValue == m_ulCompareValue); } else { // Must be an integer type bReset = (testValue.lValue == m_lCompareValue); } } else if (m_lTestCondition == HM_GE) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)<0) { bReset = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)<0) { bReset = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bReset = (i64Value < m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)<0) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { bReset = (testValue.fValue < m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bReset = (testValue.dValue < m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bReset = (testValue.i64Value < m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bReset = (testValue.ui64Value < m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bReset = (testValue.ulValue < m_ulCompareValue); } else { // Must be an integer type bReset = (testValue.lValue < m_lCompareValue); } } else if (m_lTestCondition == HM_LE) { if (ppn->type == CIM_STRING) { bAllDigits = FALSE; i = 0; while (szTestValue[i]) { if (i==0) bAllDigits = TRUE; if (!iswdigit(szTestValue[i])) { bAllDigits = FALSE; break; } i++; } if (bAllDigits == FALSE) { if (mg_bEnglishCompare == TRUE) { if (_wcsicmp(szTestValue, m_szCompareValue)>0) { bReset = TRUE; } } else { if (_wcsicoll(szTestValue, m_szCompareValue)>0) { bReset = TRUE; } } } else { __int64 i64Value = _wtoi64(szTestValue); bReset = (i64Value > m_i64CompareValue); } } else if (ppn->type == CIM_DATETIME) { if (_wcsicmp(szTestValue, m_szCompareValue)>0) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { bReset = (testValue.fValue > m_fCompareValue); } else if (ppn->type == CIM_REAL64) { bReset = (testValue.dValue > m_dCompareValue); } else if (ppn->type == CIM_SINT64) { bReset = (testValue.i64Value > m_i64CompareValue); } else if (ppn->type == CIM_UINT64) { bReset = (testValue.ui64Value > m_ui64CompareValue); } else if (ppn->type == CIM_UINT32) { bReset = (testValue.ulValue > m_ulCompareValue); } else { // Must be an integer type bReset = (testValue.lValue > m_lCompareValue); } } else if (m_lTestCondition == HM_CONTAINS) { if (ppn->type == CIM_STRING) { pszCompareValueUpper = _wcsdup(m_szCompareValue); MY_ASSERT(pszCompareValueUpper); if (!pszCompareValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszCompareValueUpper); pszTestValueUpper = _wcsdup(szTestValue); MY_ASSERT(pszTestValueUpper); if (!pszTestValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszTestValueUpper); if (!wcsstr(pszTestValueUpper, pszCompareValueUpper)) { bReset = TRUE; } free(pszCompareValueUpper); pszCompareValueUpper = NULL; free(pszTestValueUpper); pszTestValueUpper = NULL; } else if (ppn->type == CIM_DATETIME) { if (!wcsstr(szTestValue, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { _gcvt((double)testValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (!wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_REAL64) { _gcvt(testValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (!wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_SINT64) { _i64tow(testValue.i64Value, szTemp, 10 ); if (!wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_UINT64) { _ui64tow((int)testValue.ui64Value, szTemp, 10); if (!wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_UINT32) { // Must be an integer type _ultow(testValue.ulValue, szTemp, 10); if (!wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else { // Must be an integer type _ltow(testValue.lValue, szTemp, 10); if (!wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } } else if (m_lTestCondition == HM_NOTCONTAINS) { if (ppn->type == CIM_STRING) { pszCompareValueUpper = _wcsdup(m_szCompareValue); MY_ASSERT(pszCompareValueUpper); if (!pszCompareValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszCompareValueUpper); pszTestValueUpper = _wcsdup(szTestValue); MY_ASSERT(pszTestValueUpper); if (!pszTestValueUpper) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} _wcsupr(pszTestValueUpper); if (wcsstr(pszTestValueUpper, pszCompareValueUpper)) { bReset = TRUE; } free(pszCompareValueUpper); pszCompareValueUpper = NULL; free(pszTestValueUpper); pszTestValueUpper = NULL; } else if (ppn->type == CIM_DATETIME) { if (wcsstr(szTestValue, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_REAL32) { _gcvt((double)testValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_REAL64) { _gcvt(testValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; if (wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_SINT64) { _i64tow(testValue.i64Value, szTemp, 10 ); if (wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_UINT64) { _ui64tow((int)testValue.ui64Value, szTemp, 10); if (wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else if (ppn->type == CIM_UINT32) { _ultow(testValue.ulValue, szTemp, 10); if (wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } else { // Must be an integer type _ltow(testValue.lValue, szTemp, 10); if (wcsstr(szTemp, m_szCompareValue)) { bReset = TRUE; } } } else if (m_lTestCondition == HM_ALWAYS) { } else { MY_ASSERT(FALSE); } // // Now see if the duration test has been met // if (bReset) { pirs->lCurrState = HM_GOOD; pirs->lCrossCountTry = 0; } else { } MY_OUTPUT(L"EXIT ***** RearmTest...", 1); return TRUE; error: MY_ASSERT(FALSE); if (pszCompareValueUpper) free(pszCompareValueUpper); if (pszTestValueUpper) free(pszTestValueUpper); Cleanup(FALSE); m_bValidLoad = FALSE; return FALSE; } LPTSTR CThreshold::GetPropertyName(void) { return m_szPropertyName; } HRESULT CThreshold::GetHMThresholdStatusInstance(IWbemClassObject** ppThresholdInstance, BOOL bEventBased) { TCHAR szTemp[1024]; IWbemClassObject* pClass = NULL; BSTR bsString = NULL; HRESULT hRes; DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH + 2; TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 2]; MY_OUTPUT(_T("ENTER ***** GetHMSystemStatusInstance..."), 1); if (bEventBased) { bsString = SysAllocString(L"MicrosoftHM_ThresholdStatusEvent"); } else { bsString = SysAllocString(L"MicrosoftHM_ThresholdStatus"); } MY_ASSERT(bsString); if (!bsString) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} hRes = g_pIWbemServices->GetObject(bsString, 0L, NULL, &pClass, NULL); SysFreeString(bsString); bsString = NULL; MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = pClass->SpawnInstance(0, ppThresholdInstance); pClass->Release(); pClass = NULL; MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; if (m_bValidLoad == FALSE) { hRes = PutStrProperty(*ppThresholdInstance, L"GUID", m_szGUID); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = PutUint32Property(*ppThresholdInstance, L"State", HM_CRITICAL); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; if (g_hResLib == NULL || !LoadString(g_hResLib, HMRES_THRESHOLD_LOADFAIL, szTemp, 1024)) { wcscpy(szTemp, L"Threshold failed to load."); } hRes = PutStrProperty(*ppThresholdInstance, L"Message", szTemp); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = PutStrProperty(*ppThresholdInstance, L"Name", L"..."); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; } else { hRes = PutStrProperty(*ppThresholdInstance, L"GUID", m_szGUID); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = PutStrProperty(*ppThresholdInstance, L"ParentGUID", m_pParentDC->m_szGUID); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = PutStrProperty(*ppThresholdInstance, L"Name", m_szName); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; if (GetComputerName(szComputerName, &dwNameLen)) { hRes = PutStrProperty(*ppThresholdInstance, L"SystemName", szComputerName); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; } else { hRes = PutStrProperty(*ppThresholdInstance, L"SystemName", L"LocalMachine"); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; } hRes = PutStrProperty(*ppThresholdInstance, L"TimeGeneratedGMT", m_szDTTime); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; hRes = PutStrProperty(*ppThresholdInstance, L"LocalTimeFormatted", m_szTime); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; if (m_lCurrState==HM_RESET || (m_lViolationToState==HM_RESET && m_lCurrState==HM_COLLECTING)) hRes = PutUint32Property(*ppThresholdInstance, L"State", HM_GOOD); else hRes = PutUint32Property(*ppThresholdInstance, L"State", m_lCurrState); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; } MY_OUTPUT(_T("EXIT ***** GetHMSystemStatusInstance..."), 1); return hRes; error: MY_ASSERT(FALSE); if (bsString) SysFreeString(bsString); if (pClass) pClass->Release(); Cleanup(FALSE); m_bValidLoad = FALSE; return hRes; } // For a single GetObject HRESULT CThreshold::SendHMThresholdStatusInstance(IWbemObjectSink* pSink, LPTSTR pszGUID) { MY_ASSERT(pSink!=NULL); // // Is this the one we are looking for? // if (!_wcsicmp(m_szGUID, pszGUID)) { //XXX if (m_bValidLoad == FALSE) //XXX return WBEM_E_INVALID_OBJECT; return SendHMThresholdStatusInstances(pSink); } else { return WBEM_S_DIFFERENT; } } // This one is for enumeration of all HMThresholdStatus Instances outside of the hierarchy. // Just the flat list. HRESULT CThreshold::SendHMThresholdStatusInstances(IWbemObjectSink* pSink) { HRESULT hRes = S_OK; IWbemClassObject* pInstance = NULL; MY_OUTPUT(L"ENTER ***** SendHMThresholdStatusInstances...", 2); //XXX if (m_bValidLoad == FALSE) //XXX return WBEM_E_INVALID_OBJECT; if (pSink == NULL) { MY_OUTPUT(L"CDC::SendInitialHMMachStatInstances-Invalid Sink", 1); return WBEM_E_FAILED; } hRes = GetHMThresholdStatusInstance(&pInstance, FALSE); if (SUCCEEDED(hRes)) { hRes = pSink->Indicate(1, &pInstance); if (FAILED(hRes) && hRes!=WBEM_E_SERVER_TOO_BUSY && hRes!=WBEM_E_CALL_CANCELLED && hRes!=WBEM_E_TRANSPORT_FAILURE) { MY_HRESASSERT(hRes); MY_OUTPUT(L"SendHMThresholdStatusInstances-failed to send status!", 1); } pInstance->Release(); pInstance = NULL; } else { MY_HRESASSERT(hRes); MY_OUTPUT(L":SendHMThresholdStatusInstances-failed to get instance!", 1); } MY_OUTPUT(L"EXIT ***** SendHMThresholdStatusInstances...", 2); return hRes; } #ifdef SAVE // For a single GetObject HRESULT CThreshold::SendHMThresholdStatusInstanceInstance(ACTUALINSTLIST *actualInstList, PNSTRUCT *ppn, IWbemObjectSink* pSink, LPTSTR pszGUID) { MY_OUTPUT(L"ENTER ***** SendHMThresholdStatusInstance...", 1); // // Is this the one we are looking for? // if (!_wcsicmp(m_szGUID, pszGUID)) { SendHMThresholdStatusInstanceInstances(actualInstList, ppn, pSink); return TRUE; } MY_OUTPUT(L"EXIT ***** SendHMThresholdStatusInstance...", 1); return FALSE; } // This one is for enumeration of all HMThresholdStatus Instances outside of the hierarchy. // Just the flat list. HRESULT CThreshold::SendHMThresholdStatusInstanceInstances(ACTUALINSTLIST *actualInstList, PNSTRUCT *ppn, IWbemObjectSink* pSink) { int i, iSize; IRSSTRUCT *pirs; INSTSTRUCT *pinst; HRESULT hRes = S_OK; IWbemClassObject* pObj = NULL; ACTUALINSTSTRUCT *pActualInst; MY_OUTPUT(L"ENTER ***** SendHMSystemStatusInstances...", 2); if (pSink == NULL) { MY_OUTPUT(L"CDP::SendInitialHMMachStatInstances-Invalid Sink", 1); return WBEM_E_INVALID_PARAMETER; } //XXXABC // MY_ASSERT(m_irsList.size() == actualInstList->size()); if (_wcsicmp(m_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(m_szPropertyName, L"CollectionErrorDescription")) { MY_ASSERT(m_irsList.size() == actualInstList->size()); } iSize = m_irsList.size(); for (i=0; iinstList.size()); pinst = &ppn->instList[i]; MY_ASSERT(iIndicate(1, &pObj); if (FAILED(hRes) && hRes != WBEM_E_SERVER_TOO_BUSY) { MY_HRESASSERT(hRes); MY_OUTPUT(L"SendHMSystemStatusInstances-failed to send status!", 1); } pObj->Release(); pObj = NULL; } else { MY_HRESASSERT(hRes); MY_OUTPUT(L":SendHMSystemStatusInstances-failed to get instance!", 1); } } MY_OUTPUT(L"EXIT ***** SendHMSystemStatusInstances...", 2); return hRes; } #endif long CThreshold::GetCurrState(void) { return m_lCurrState; } HRESULT CThreshold::FindAndModThreshold(BSTR szGUID, IWbemClassObject* pObj) { HRESULT hRes = S_OK; // // Is this us we are looking for? // if (!_wcsicmp(m_szGUID, szGUID)) { hRes = LoadInstanceFromMOF(pObj, NULL, L"", TRUE); return hRes; } return WBEM_S_DIFFERENT; } LPTSTR CThreshold::GetGUID(void) { return m_szGUID; } BOOL CThreshold::SetParentEnabledFlag(BOOL bEnabled) { m_bParentEnabled = bEnabled; return TRUE; } BOOL CThreshold::SetParentScheduledOutFlag(BOOL bScheduledOut) { m_bParentScheduledOut = bScheduledOut; return TRUE; } BOOL CThreshold::SetCurrState(HM_STATE state, BOOL bForce/*=FALSE*/, int reason/* = 0*/) { int i, iSize; IRSSTRUCT *pirs; if (m_pParentDC->m_deType==HM_EQDE && (m_bEnabled==FALSE || m_bParentEnabled==FALSE)) { if (m_lCurrState!=HM_DISABLED) { m_lCurrState = HM_DISABLED; m_lNumberChanges++; } return TRUE; } m_lNumberChanges = 0; iSize = m_irsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ilCurrState != state) { m_lNumberChanges++; } pirs->lCurrState = state; pirs->unknownReason = reason; } if (iSize==0 || bForce) { if (m_lCurrState!=state || bForce) { m_lNumberChanges++; } } m_lCurrState = state; return TRUE; } BOOL CThreshold::SetBackPrev(PNSTRUCT *ppn) { int i, iSize; IRSSTRUCT *pirs; iSize = m_irsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(itype == CIM_REAL32) { pirs->fPrevValue = pirs->fPrevPrevValue; } else if (ppn->type == CIM_REAL64) { pirs->dPrevValue = pirs->dPrevPrevValue; } else if (ppn->type == CIM_SINT64) { pirs->i64PrevValue = pirs->i64PrevPrevValue; } else if (ppn->type == CIM_UINT64) { pirs->ui64PrevValue = pirs->ui64PrevPrevValue; } else if (ppn->type == CIM_UINT32) { pirs->ulPrevValue = pirs->ulPrevPrevValue; } else { pirs->lPrevValue = pirs->lPrevPrevValue; } } return TRUE; } BOOL CThreshold::ResetResetThreshold(void) { int i, iSize; IRSSTRUCT *pirs; m_lCurrState = HM_RESET; m_lPrevState = HM_RESET; iSize = m_irsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ilCurrState = HM_RESET; pirs->lPrevState = HM_RESET; pirs->unknownReason = 0; } m_lNumberChanges = 0; return TRUE; } BOOL CThreshold::GetChange(void) { if (m_lNumberChanges!=0 && m_lPrevState!=m_lCurrState) { return TRUE; } else { return FALSE; } } BOOL CThreshold::GetEnabledChange(void) { BOOL bChanged = FALSE; if ((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState!=HM_DISABLED) { bChanged = TRUE; } if ((m_bEnabled==TRUE && m_bParentEnabled==TRUE) && m_lCurrState==HM_DISABLED) { bChanged = TRUE; } return bChanged; } HRESULT CThreshold::AddInstance(LPTSTR pszID) { HRESULT hRes = S_OK; GUID guid; IRSSTRUCT irs; irs.szInstanceID = new TCHAR[wcslen(pszID)+2]; MY_ASSERT(irs.szInstanceID); if (!irs.szInstanceID) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(irs.szInstanceID, pszID); // yyyymmddhhmmss.ssssssXUtc; X = GMT(+ or -), Utc = 3 dig. offset from UTC.")] wcscpy(irs.szDTTime, m_szDTCurrTime); wcscpy(irs.szTime, m_szCurrTime); hRes = CoCreateGuid(&guid); MY_HRESASSERT(hRes); if (hRes!=S_OK) goto error; irs.szStatusGUID = new TCHAR[100]; MY_ASSERT(irs.szStatusGUID); if (!irs.szStatusGUID) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} StringFromGUID2(guid, irs.szStatusGUID, 100); irs.lCurrState = HM_COLLECTING; irs.lPrevState = HM_COLLECTING; irs.unknownReason = 0; irs.lCrossCountTry = 0; irs.fPrevValue = MAX_FLOAT; irs.dPrevValue = MAX_DOUBLE; irs.i64PrevValue = MAX_I64; irs.ui64PrevValue = MAX_UI64; irs.lPrevValue = MAX_LONG; irs.ulPrevValue = MAX_ULONG; irs.bNeeded = TRUE; m_irsList.push_back(irs); return S_OK; error: MY_ASSERT(FALSE); Cleanup(FALSE); m_bValidLoad = FALSE; return hRes; } BOOL CThreshold::ClearInstList(void) { int i, iSize; IRSSTRUCT *pirs; iSize = m_irsList.size(); for (i=0; iszInstanceID) { delete [] pirs->szInstanceID; } if (pirs->szStatusGUID) { delete [] pirs->szStatusGUID; } } m_irsList.clear(); return TRUE; } #ifdef SAVE // // Do string replacement for the Message property // BOOL CThreshold::FormatMessage(IWbemClassObject* pIRSInstance, IWbemClassObject *pEmbeddedInstance) { // TCHAR szMsg[1024]; BSTR PropName = NULL; LPTSTR pszMsg = NULL; SAFEARRAY *psaNames = NULL; long lNum; HRESULT hRes; LPTSTR pszDest; LPTSTR pszUpperMsg; LPTSTR pszNewMsg; LPTSTR pStr; LPTSTR pStrStart; TOKENSTRUCT tokenElmnt; TOKENSTRUCT *pTokenElmnt; REPSTRUCT repElmnt; REPSTRUCT *pRepElmnt; REPSTRUCT *pRepElmnt2; REPLIST replacementList; int i, iSize, iSizeNeeded, j; // long lMessageRID; long lLower, lUpper; // long iLBound, iUBound; // IUnknown* vUnknown; static TOKENLIST tokenList; // int iRet; TOKENLIST embeddedInstTokenList; // // We only need to build the set of tokens one time, then from then on // we just need to fill in the values for what the replacement strings are. // if (tokenList.size() == 0) { // // First we build the set of tokens that we are looking for. Each property that // is in the ThresholdStatusInstance. We build that set of strings, // and the values to replace with. // // // Now go through ThresholdInstance, which is where the Message String // actually lives. Get that set of properties for the Instances. // psaNames = NULL; hRes = pIRSInstance->GetNames(NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames); if (SUCCEEDED(hRes)) { // Get the number of properties. SafeArrayGetLBound(psaNames, 1, &lLower); SafeArrayGetUBound(psaNames, 1, &lUpper); // For each property... for (long l=lLower; l<=lUpper; l++) { // Get this property. hRes = SafeArrayGetElement(psaNames, &l, &PropName); if (SUCCEEDED(hRes)) { // Will want to skip some that don't make sense. if (!wcscmp(PropName, L"Message")) { SysFreeString(PropName); PropName = NULL; continue; } else if (!wcscmp(PropName, L"ResetMessage")) { SysFreeString(PropName); PropName = NULL; continue; } else if (!wcscmp(PropName, L"EmbeddedInstance")) { SysFreeString(PropName); PropName = NULL; continue; } tokenElmnt.szOrigToken = new TCHAR[wcslen(PropName)+1]; wcscpy(tokenElmnt.szOrigToken, PropName); tokenElmnt.szToken = new TCHAR[wcslen(PropName)+3]; wcscpy(tokenElmnt.szToken, L"%"); wcscat(tokenElmnt.szToken, PropName); wcscat(tokenElmnt.szToken, L"%"); _wcsupr(tokenElmnt.szToken); tokenElmnt.szReplacementText = NULL; tokenList.push_back(tokenElmnt); SysFreeString(PropName); PropName = NULL; } } SafeArrayDestroy(psaNames); } } // // Populate the list of properties on the embedded instance that came from the // Data Collector. // if (_wcsicmp(m_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(m_szPropertyName, L"CollectionErrorDescription")) { psaNames = NULL; MY_ASSERT(pEmbeddedInstance); hRes = pEmbeddedInstance->GetNames(NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames); if (SUCCEEDED(hRes)) { // Get the number of properties. SafeArrayGetLBound(psaNames, 1, &lLower); SafeArrayGetUBound(psaNames, 1, &lUpper); // For each property... for (long l=lLower; l<=lUpper; l++) { // Get this property. hRes = SafeArrayGetElement(psaNames, &l, &PropName); if (SUCCEEDED(hRes)) { tokenElmnt.szOrigToken = new TCHAR[wcslen(PropName)+1]; wcscpy(tokenElmnt.szOrigToken, PropName); tokenElmnt.szToken = new TCHAR[wcslen(PropName)+20]; wcscpy(tokenElmnt.szToken, L"%"); wcscat(tokenElmnt.szToken, L"EmbeddedInstance."); wcscat(tokenElmnt.szToken, PropName); wcscat(tokenElmnt.szToken, L"%"); _wcsupr(tokenElmnt.szToken); tokenElmnt.szReplacementText = NULL; embeddedInstTokenList.push_back(tokenElmnt); SysFreeString(PropName); PropName = NULL; } } SafeArrayDestroy(psaNames); } } // // Now we can fill in the values to use for the replacement strings. // // // Now go through each ThresholdInstance, which is where the Message String // actually lives. Get that set of properties of the Instance, // And do the message formatting while there. // // // Get the replacement strings for this instance // iSize = tokenList.size(); for (i=0; iszReplacementText != NULL) { delete [] pTokenElmnt->szReplacementText; } if (!wcscmp(pTokenElmnt->szToken, L"%TESTCONDITION%")) { hRes = GetUint32Property(pIRSInstance, pTokenElmnt->szOrigToken, &lNum); MY_HRESASSERT(hRes); MY_ASSERT(lNum<9); pStr = new TCHAR[wcslen(condition[lNum])+1]; wcscpy(pStr, condition[lNum]); } else if (!wcscmp(pTokenElmnt->szToken, L"%STATE%")) { hRes = GetUint32Property(pIRSInstance, pTokenElmnt->szOrigToken, &lNum); MY_HRESASSERT(hRes); MY_ASSERT(lNum<10); pStr = new TCHAR[wcslen(state[lNum])+1]; wcscpy(pStr, state[lNum]); } else { hRes = GetAsStrProperty(pIRSInstance, pTokenElmnt->szOrigToken, &pStr); } pTokenElmnt->szReplacementText = pStr; MY_HRESASSERT(hRes); } // // Get the replacement strings for this instance - Embedded // iSize = embeddedInstTokenList.size(); for (i=0; iszReplacementText != NULL) { delete [] pTokenElmnt->szReplacementText; } MY_ASSERT(pEmbeddedInstance); hRes = GetAsStrProperty(pEmbeddedInstance, pTokenElmnt->szOrigToken, &pStr); pTokenElmnt->szReplacementText = pStr; MY_HRESASSERT(hRes); } // // Now we have both lists of tokens that have replacement // strings that go with them and the replacement strings // that go with them // // // Do formatting of Message. We replace all Variable Tags. // Sample string - // "Drive %InstanceName% is full. Currently at %CurrentValue%%." // // // Get the origional un-formatted message first. // To make case in-sensitive, do a _strdup and then a _wcsupr on the string // to scan run the code on it, and then free the duplicated string. // // If it uses resource IDs, then get that string first, then format that!!! hRes = GetStrProperty(pIRSInstance, L"Message", &pszMsg); MY_HRESASSERT(hRes); // if (!wcscmp(pszMsg, L"")) // { // delete [] pszMsg; // hRes = GetUint32Property(pIRSInstance, L"MessageStringRID", &lMessageRID); // MY_HRESASSERT(hRes); // if (m_hResLib == NULL) // { // wcscpy(szMsg , L"Resource DLL not found"); // } // else // { // TCHAR szMsg[1024]; // int iRet; // iRet = LoadString(m_hResLib, lMessageRID, szMsg, 1024); // if (iRet == 0) // { // wcscpy(szMsg , L"Resource string not found"); // } // } // pszMsg = new TCHAR[wcslen(szMsg)+2]; // wcscpy(pszMsg , szMsg); // } // else // { // hRes = GetStrProperty(pIRSInstance, L"Message", &pszMsg); // MY_HRESASSERT(hRes); // } pszUpperMsg = _wcsdup(pszMsg); _wcsupr(pszUpperMsg); // // First loop through and find every token that needs replacing. // Put that info into the replacement list. // // We will do strstr() for each special token until there are no more to find // for each. At each find we will store the offset into the string of what // we found. Then we sort by what came first. // // Quick test to see if it is worth searching if (wcschr(pszUpperMsg, '%')) { iSize = tokenList.size(); pStrStart = pszUpperMsg; for (i=0; iszToken); if (pStr != NULL) { repElmnt.pStartStr = pszMsg+(pStr-pszUpperMsg); repElmnt.len = wcslen(pTokenElmnt->szToken); repElmnt.pszReplacementText = pTokenElmnt->szReplacementText; replacementList.push_back(repElmnt); i--; pStrStart = pStr+1; } else { pStrStart = pszUpperMsg; } } // Embedded stuff iSize = embeddedInstTokenList.size(); pStrStart = pszUpperMsg; for (i=0; iszToken); if (pStr != NULL) { repElmnt.pStartStr = pszMsg+(pStr-pszUpperMsg); repElmnt.len = wcslen(pTokenElmnt->szToken); repElmnt.pszReplacementText = pTokenElmnt->szReplacementText; replacementList.push_back(repElmnt); i--; pStrStart = pStr+1; } else { pStrStart = pszUpperMsg; } } // // Need to look for replacement strings that have not been replaced. // Simply search for %EmbeddedCollectedInstance. and find the end % for each // Replace them with // if (!pEmbeddedInstance) { pStrStart = pszUpperMsg; while (TRUE) { pStr = wcsstr(pStrStart, L"%EMBEDDEDCOLLECTEDINSTANCE."); if (pStr != NULL) { repElmnt.pStartStr = pszMsg+(pStr-pszUpperMsg); pStr2 = pStr; while (pStr2++) { if (*pStr2=='%' || iswspace(*pStr2)) break; } if (*pStr2=='%') { repElmnt.len = (pStr2-pStr)+1; repElmnt.pszReplacementText = L""; replacementList.push_back(repElmnt); } pStrStart = pStr+1; } else { break; } } } } iSize = replacementList.size(); if (iSize != 0) { // // Next, sort the replacement list from the first string to // be replaced, to the last. Shell sort, Knuth, Vol13, pg. 84. // for (int gap=iSize/2; 0pStartStr < pRepElmnt2->pStartStr) { MY_ASSERT(jlen; iSizeNeeded += wcslen(pRepElmnt->pszReplacementText); } pszNewMsg = new TCHAR[iSizeNeeded]; *pszNewMsg = '\0'; // // Next, we loop through and do the actual replacements. // "Drive %InstanceName% is full. Currently at %CurrentValue%%." // pszDest = pszMsg; iSize = replacementList.size(); for (i=0; ipStartStr) = '\0'; wcscat(pszNewMsg, pszDest); wcscat(pszNewMsg, pRepElmnt->pszReplacementText); //XXXWould memcpy be faster??? memcpy(pszDest, source, charCnt*sizeof(TCHAR)); pszDest = pRepElmnt->pStartStr+pRepElmnt->len; } wcscat(pszNewMsg, pszDest); PutStrProperty(pIRSInstance, L"Message", pszNewMsg); delete [] pszNewMsg; replacementList.clear(); } else { PutStrProperty(pIRSInstance, L"Message", pszMsg); } delete [] pszMsg; free(pszUpperMsg); // Free up the temporary token list iSize = embeddedInstTokenList.size(); for (i=0; iszToken) delete [] pTokenElmnt->szToken; if (pTokenElmnt->szOrigToken) delete [] pTokenElmnt->szOrigToken; if (pTokenElmnt->szReplacementText) delete [] pTokenElmnt->szReplacementText; } embeddedInstTokenList.clear(); return TRUE; } #endif BOOL CThreshold::Init(void) { MY_OUTPUT(L"ENTER ***** CThreshold::Init...", 4); m_bParentScheduledOut = FALSE; m_lNumberNormals = 0; m_lNumberWarnings = 0; m_lNumberCriticals = 0; m_lNumberChanges = 0; m_lCompareValue = -99999; m_lCurrState = HM_COLLECTING; m_lPrevState = HM_COLLECTING; m_szGUID = NULL; m_szParentObjPath = NULL; m_pParentDC = NULL; m_szName = NULL; m_szDescription = NULL; m_szPropertyName = NULL; m_szCompareValue = NULL; m_szCreationDate = NULL; m_szLastUpdate = NULL; // m_szMessage = NULL; // m_szResetMessage = NULL; // m_lID = 0; m_bUseAverage = FALSE; m_bUseDifference = FALSE; m_bUseSum = FALSE; m_lTestCondition = 0; m_lThresholdDuration = 0; m_lViolationToState = 9; m_lStartupDelay = 0; m_bEnabled = TRUE; m_bParentEnabled = TRUE; // yyyymmddhhmmss.ssssssXUtc; X = GMT(+ or -), Utc = 3 dig. offset from UTC.")] wcscpy(m_szDTTime, m_szDTCurrTime); wcscpy(m_szTime, m_szCurrTime); MY_OUTPUT(L"EXIT ***** CThreshold::Init...", 4); return TRUE; } BOOL CThreshold::Cleanup(BOOL bSavePrevSettings) { int i, iSize; IRSSTRUCT *pirs; MY_OUTPUT(L"ENTER ***** CThreshold::Cleanup...", 4); if (bSavePrevSettings == FALSE) { if (m_szParentObjPath) { delete [] m_szParentObjPath; m_szParentObjPath = NULL; } } if (m_szName) { delete [] m_szName; m_szName = NULL; } if (m_szDescription) { delete [] m_szDescription; m_szDescription = NULL; } if (m_szPropertyName) { delete [] m_szPropertyName; m_szPropertyName = NULL; } if (m_szCompareValue) { delete [] m_szCompareValue; m_szCompareValue = NULL; } if (m_szCreationDate) { delete [] m_szCreationDate; m_szCreationDate = NULL; } if (m_szLastUpdate) { delete [] m_szLastUpdate; m_szLastUpdate = NULL; } // if (m_szMessage) // { // delete [] m_szMessage; // m_szMessage = NULL; // } // if (m_szResetMessage) // { // delete [] m_szResetMessage; // m_szResetMessage = NULL; // } if (bSavePrevSettings) { iSize = m_irsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ilCrossCountTry = 0; pirs->fPrevValue = MAX_FLOAT; pirs->dPrevValue = MAX_DOUBLE; pirs->i64PrevValue = MAX_I64; pirs->ui64PrevValue = MAX_UI64; pirs->lPrevValue = MAX_LONG; pirs->ulPrevValue = MAX_ULONG; } } else { iSize = m_irsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iszInstanceID) { delete [] pirs->szInstanceID; } if (pirs->szStatusGUID) { delete [] pirs->szStatusGUID; } } m_irsList.clear(); } MY_OUTPUT(L"EXIT ***** CThreshold::Cleanup...", 4); return TRUE; } // // For when moving from one parent to another // #ifdef SAVE BOOL CThreshold::ModifyAssocForMove(CBase *pNewParentBase) { HRESULT hRes; TCHAR szTemp[1024]; TCHAR szNewTemp[1024]; BSTR instName; IWbemContext *pCtx = 0; IWbemCallResult *pResult = 0; IWbemClassObject* pObj = NULL; IWbemClassObject* pNewObj = NULL; MY_OUTPUT(L"ENTER ***** CDataGroup::ModifyAssocForMove...", 4); MY_OUTPUT2(L"m_szGUID=%s", m_szGUID, 4); // // Figure out the new parent path // if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_EQDE) { wcscpy(szNewTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\""); } else if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_PGDE) { wcscpy(szNewTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\""); } else if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_PMDE) { wcscpy(szNewTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\""); } else if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_PQDE) { wcscpy(szNewTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\""); } else { MY_ASSERT(FALSE); } lstrcat(szNewTemp, pNewParentBase->m_szGUID); lstrcat(szNewTemp, L"\""); // // Delete the association from my parent to me. // wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHealthMonitor:MicrosoftHM_ThresholdConfiguration.GUID=\\\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\""); instName = SysAllocString(L"MicrosoftHM_ConfigurationAssociation"); if ((hRes = g_pIWbemServices->GetObject(instName, 0L, NULL, &pObj, NULL)) != S_OK) { MY_HRESASSERT(hRes); } SysFreeString(instName); if (pObj) { hRes = pObj->SpawnInstance(0, &pNewObj); pObj->Release(); PutStrProperty(pNewObj, L"ChildPath", szTemp); PutStrProperty(pNewObj, L"ParentPath", szNewTemp); hRes = g_pIWbemServices->PutInstance(pNewObj, 0, NULL, &pResult); pNewObj->Release(); pNewObj = NULL; } DeleteThresholdConfig(TRUE); if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_EQDE) { wcscpy(szNewTemp, L"MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\\\""); } else if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_PGDE) { wcscpy(szNewTemp, L"MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\\\""); } else if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_PMDE) { wcscpy(szNewTemp, L"MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\\\""); } else if (pNewParentBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR && ((CDataCollector *)pNewParentBase)->m_deType == HM_PQDE) { wcscpy(szNewTemp, L"MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\\\""); } else { MY_ASSERT(FALSE); } lstrcat(szNewTemp, pNewParentBase->m_szGUID); lstrcat(szNewTemp, L"\\\""); if (m_szParentObjPath) { delete [] m_szParentObjPath; } m_szParentObjPath = new TCHAR[wcslen(szNewTemp)+1]; wcscpy(m_szParentObjPath, szNewTemp); m_pParentDC = (CDataCollector *)pNewParentBase; MY_OUTPUT(L"EXIT ***** CDataGroup::ModifyAssocForMove...", 4); return TRUE; } #endif BOOL CThreshold::ReceiveNewChildForMove(CBase *pBase) { MY_ASSERT(FALSE); return FALSE; } BOOL CThreshold::DeleteChildFromList(LPTSTR pszGUID) { MY_ASSERT(FALSE); return FALSE; } BOOL CThreshold::DeleteThresholdConfig(BOOL bDeleteAssocOnly) { HRESULT hRes = S_OK; TCHAR szTemp[1024]; BSTR instName = NULL; LPTSTR pszStr = NULL; MY_OUTPUT(L"ENTER ***** CThreshold::DeleteThresholdConfig...", 4); MY_OUTPUT2(L"m_szGUID=%s", m_szGUID, 4); // // Delete the association from my parent to me. // For some reason, we have to try twice, as we can't count on what will be there. // wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_ThresholdConfiguration.GUID=\\\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\\\"\",ParentPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:"); lstrcat(szTemp, m_szParentObjPath); lstrcat(szTemp, L"\""); instName = SysAllocString(szTemp); MY_ASSERT(instName); if (!instName) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} if ((hRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK) { SysFreeString(instName); instName = NULL; wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_ThresholdConfiguration.GUID=\\\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\\\"\",ParentPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:"); lstrcat(szTemp, L"MicrosoftHM_DataCollectorConfiguration."); pszStr = wcsstr(m_szParentObjPath, L"GUID"); lstrcat(szTemp, pszStr); lstrcat(szTemp, L"\""); instName = SysAllocString(szTemp); MY_ASSERT(instName); if (!instName) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} if ((hRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK) { MY_OUTPUT2(L"Threshold delete failure GUID=%s", instName, 4); } } SysFreeString(instName); instName = NULL; if (bDeleteAssocOnly) { return TRUE; } // // Delete our exact instance // wcscpy(szTemp, L"MicrosoftHM_ThresholdConfiguration.GUID=\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\""); instName = SysAllocString(szTemp); MY_ASSERT(instName); if (!instName) {hRes = WBEM_E_OUT_OF_MEMORY; goto error;} if ((hRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK) { MY_HRESASSERT(hRes); MY_OUTPUT2(L"Threshold delete failure GUID=%s", instName, 4); } SysFreeString(instName); instName = NULL; // // Get rid of any associations to actions for this // g_pSystem->DeleteAllConfigActionAssoc(m_szGUID); MY_OUTPUT(L"EXIT ***** CThreshold::DeleteThresholdConfig...", 4); return TRUE; error: MY_ASSERT(FALSE); if (instName) SysFreeString(instName); Cleanup(FALSE); m_bValidLoad = FALSE; return FALSE; } HRESULT CThreshold::Copy(ILIST* pConfigList, LPTSTR pszOldParentGUID, LPTSTR pszNewParentGUID) { GUID guid; TCHAR szTemp[1024]; TCHAR szNewGUID[1024]; IWbemClassObject* pInst = NULL; IWbemClassObject* pInstCopy = NULL; IWbemClassObject* pInstAssocCopy = NULL; IWbemClassObject* pObj = NULL; HRESULT hRetRes = S_OK; BSTR Language = NULL; BSTR Query = NULL; IEnumWbemClassObject *pEnum; ULONG uReturned; IWbemContext *pCtx = 0; LPTSTR pszParentPath = NULL; LPTSTR pszChildPath = NULL; LPTSTR pStr = NULL; MY_OUTPUT(L"ENTER ***** CThreshold::Copy...", 1); if (m_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; // // Get the origional starting point HMConfiguration instance. // wcscpy(szTemp, L"MicrosoftHM_Configuration.GUID=\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\""); hRetRes = GetWbemObjectInst(&g_pIWbemServices, szTemp, NULL, &pInst); if (!pInst) { MY_HRESASSERT(hRetRes); return hRetRes; } // // Clone the instance, and change the GUID // hRetRes = pInst->Clone(&pInstCopy); if (FAILED(hRetRes)) { MY_HRESASSERT(hRetRes); pInst->Release(); pInst = NULL; return hRetRes; } hRetRes = CoCreateGuid(&guid); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StringFromGUID2(guid, szNewGUID, 100); hRetRes = PutStrProperty(pInstCopy, L"GUID", szNewGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pConfigList->push_back(pInstCopy); // // Add instance of HMConfigurationAssociation where we are the child, // using the parent GUID passed in. // Change the GUIDs of both the Parent and Child. // also make sure that the machine name is not in the path, and is relative! // if (pszOldParentGUID != NULL) { Language = SysAllocString(L"WQL"); MY_ASSERT(Language); if (!Language) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(szTemp, L"REFERENCES OF {MicrosoftHM_Configuration.GUID=\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\"} WHERE ResultClass=MicrosoftHM_ConfigurationAssociation Role=ChildPath"); Query = SysAllocString(szTemp); MY_ASSERT(Query); if (!Query) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} // Initialize IEnumWbemClassObject pointer pEnum = 0; // Issue query hRetRes = g_pIWbemServices->ExecQuery(Language, Query, WBEM_FLAG_FORWARD_ONLY, 0, &pEnum); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; SysFreeString(Query); Query = NULL; SysFreeString(Query); Language = NULL; // Retrieve object in result set pObj = NULL; uReturned = 0; hRetRes = pEnum->Next(0, 1, &pObj, &uReturned); if (uReturned == 0) { hRetRes = WBEM_E_INVALID_OBJECT_PATH; goto error; } // // Change the GUIDs // hRetRes = GetStrProperty(pObj, L"ParentPath", &pszParentPath); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetStrProperty(pObj, L"ChildPath", &pszChildPath); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pStr = wcschr(pszParentPath, '\"'); if (pStr) { pStr++; wcsncpy(pStr, pszNewParentGUID, wcslen(pszNewParentGUID)); } else { hRetRes = WBEM_E_INVALID_OBJECT_PATH; goto error; } pStr = wcschr(pszChildPath, '\"'); if (pStr) { pStr++; wcsncpy(pStr, szNewGUID, wcslen(szNewGUID)); } else { hRetRes = WBEM_E_INVALID_OBJECT_PATH; goto error; } hRetRes = pObj->Clone(&pInstAssocCopy); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(pInstAssocCopy, L"ParentPath", pszParentPath); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(pInstAssocCopy, L"ChildPath", pszChildPath); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pConfigList->push_back(pInstAssocCopy); // Release it. pObj->Release(); pObj = NULL; pEnum->Release(); pEnum = NULL; delete [] pszParentPath; pszParentPath = NULL; delete [] pszChildPath; pszChildPath = NULL; } pInst->Release(); pInst = NULL; MY_OUTPUT(L"EXIT ***** CThreshold::Copy...", 1); return S_OK; error: MY_ASSERT(FALSE); if (pInst) pInst->Release(); if (pObj) pObj->Release(); if (pEnum) pEnum->Release(); if (Query) SysFreeString(Query); if (Language) SysFreeString(Language); if (pszParentPath) delete [] pszParentPath; if (pszChildPath) delete [] pszChildPath; Cleanup(FALSE); m_bValidLoad = FALSE; return hRetRes; } CBase *CThreshold::FindImediateChildByName(LPTSTR pszName) { MY_ASSERT(FALSE); return NULL; } BOOL CThreshold::GetNextChildName(LPTSTR pszChildName, LPTSTR pszOutName) { MY_ASSERT(FALSE); return NULL; } CBase *CThreshold::FindPointerFromName(LPTSTR pszName) { MY_ASSERT(FALSE); return NULL; } long CThreshold::PassBackStateIfChangedPerInstance(LPTSTR pszInstName) { int i, iSize; IRSSTRUCT *pirs; BOOL bFound = FALSE; long state = -1; iSize = m_irsList.size(); for (i=0; iszInstanceID, pszInstName)) { if (pirs->lPrevState != pirs->lCurrState) { state = pirs->lCurrState; bFound = TRUE; break; } } } return state; } long CThreshold::PassBackWorstStatePerInstance(LPTSTR pszInstName) { int i, iSize; IRSSTRUCT *pirs; BOOL bFound = FALSE; long state = -1; iSize = m_irsList.size(); for (i=0; iszInstanceID, pszInstName)) { state = pirs->lCurrState; bFound = TRUE; break; } } return state; } BOOL CThreshold::SetPrevState(HM_STATE state) { int i, iSize; IRSSTRUCT *pirs; iSize = m_irsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ilCurrState = state; pirs->lPrevState = state; } m_lNumberChanges = 0; m_lCurrState = state; return TRUE; } BOOL CThreshold::SendReminderActionIfStateIsSame(IWbemObjectSink* pActionEventSink, IWbemObjectSink* pActionTriggerEventSink, IWbemClassObject* pActionInstance, IWbemClassObject* pActionTriggerInstance, unsigned long ulTriggerStates) { MY_ASSERT(FALSE); return FALSE; } HRESULT CThreshold::CheckForBadLoad(void) { HRESULT hRetRes = S_OK; IWbemClassObject* pObj = NULL; TCHAR szTemp[1024]; IWbemClassObject* pInstance = NULL; if (m_bValidLoad == FALSE) { wcscpy(szTemp, L"MicrosoftHM_ThresholdConfiguration.GUID=\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\""); hRetRes = GetWbemObjectInst(&g_pIWbemServices, szTemp, NULL, &pObj); if (!pObj) { MY_HRESASSERT(hRetRes); return S_FALSE; } hRetRes = LoadInstanceFromMOF(pObj, NULL, L"", TRUE); // Here is where we can try and send out a generic SOS if the load failed each time!!! if (hRetRes != S_OK) { if (GetHMThresholdStatusInstance(&pInstance, TRUE) == S_OK) { mg_TEventList.push_back(pInstance); } } else { if (GetHMThresholdStatusInstance(&pInstance, TRUE) == S_OK) { mg_TEventList.push_back(pInstance); } m_pParentDC->ResetState(TRUE, TRUE); } MY_HRESASSERT(hRetRes); pObj->Release(); pObj = NULL; return hRetRes; } return S_OK; }