//*************************************************************************** // // DATACLTR.CPP // // Module: HEALTHMON SERVER AGENT // // Purpose: CDataCollector class to do WMI instance collection. // // Copyright (c)1999 Microsoft Corporation, All Rights Reserved // //*************************************************************************** #include #include "datacltr.h" #include "datagrp.h" #include "system.h" extern CSystem* g_pSystem; extern CSystem* g_pStartupSystem; extern LPTSTR conditionLocStr[10]; extern LPTSTR stateLocStr[9]; // STATIC DATA NSLIST CDataCollector::mg_nsList; //STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC void CDataCollector::DETerminationCleanup(void) { NSSTRUCT *pns; int iSize; int i; // Since this is a global shared array, we need to do this // in a static function. iSize = mg_nsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ipIWbemServices->Release(); pns->pIWbemServices = NULL; if (pns->szTargetNamespace) { delete [] pns->szTargetNamespace; pns->szTargetNamespace = NULL; } if (pns->szLocal) { delete [] pns->szLocal; pns->szLocal = NULL; } } if (g_pDataCollectorEventSink != NULL) { g_pDataCollectorEventSink->Release(); g_pDataCollectorEventSink = NULL; } if (g_pDataCollectorPerInstanceEventSink != NULL) { g_pDataCollectorPerInstanceEventSink->Release(); g_pDataCollectorPerInstanceEventSink = NULL; } } ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CDataCollector::CDataCollector() { MY_OUTPUT(L"ENTER ***** CDataCollector...", 4); Init(); m_hmStatusType = HMSTATUS_DATACOLLECTOR; m_bValidLoad = FALSE; MY_OUTPUT(L"EXIT ***** CDataCollector...", 4); } CDataCollector::~CDataCollector() { MY_OUTPUT(L"ENTER ***** ~CDataCollector...", 4); g_pStartupSystem->RemovePointerFromMasterList(this); m_bValidLoad = TRUE; Cleanup(FALSE); if (m_szGUID) { delete [] m_szGUID; m_szGUID = NULL; } if (m_szParentObjPath) { delete [] m_szParentObjPath; m_szParentObjPath = NULL; } MY_OUTPUT(L"EXIT ***** ~CDataCollector...", 4); } // get polling interval in milliseconds. long CDataCollector::GetCollectionIntervalMultiple() { return m_lCollectionIntervalMultiple; } // // We keep a global static list of pointers to namespaces, so we can share them // and be more efficient about it. Each time a new one comes in, we add it to the // list. // HRESULT CDataCollector::fillInNamespacePointer(void) { HRESULT hRetRes = S_OK; int i; int iSize; BSTR bsNamespace = NULL; BSTR bsLocal = NULL; BOOL bFound = FALSE; NSSTRUCT ns; NSSTRUCT *pns; IWbemLocator *pLocator = NULL; IWbemServices *pService = NULL; ns.szTargetNamespace = NULL; ns.szLocal = NULL; MY_OUTPUT(L"ENTER ***** fillInNamespacePointer...", 4); hRetRes = CoCreateInstance(CLSID_WbemAdministrativeLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*) &pLocator); if (FAILED(hRetRes)) { MY_HRESASSERT(hRetRes); return hRetRes; } MY_ASSERT(pLocator); // We already have apointer to the local Healthmon namespace if (!_wcsicmp(m_szTargetNamespace, L"healthmon")) { m_pIWbemServices = g_pIWbemServices; } else { iSize = mg_nsList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iszTargetNamespace) && !_wcsicmp(m_szLocal, pns->szLocal)) { m_pIWbemServices = pns->pIWbemServices; bFound = TRUE; break; } } if (bFound == FALSE) { bsNamespace = SysAllocString(m_szTargetNamespace); MY_ASSERT(bsNamespace); if (!bsNamespace) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} if (_wcsicmp(m_szLocal, L"")) { bsLocal = SysAllocString(m_szLocal); MY_ASSERT(bsLocal); if (!bsLocal) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} } hRetRes = pLocator->ConnectServer(bsNamespace, NULL, NULL, bsLocal, 0L, NULL, NULL, &pService); if (FAILED(hRetRes)) { hRetRes = hRetRes; m_pIWbemServices = NULL; if (hRetRes != WBEM_E_INVALID_NAMESPACE) MY_HRESASSERT(hRetRes); MY_OUTPUT2(L"Failed to connect to namespace=%s", m_szTargetNamespace, 4); } else { // Store one in the static array m_pIWbemServices = pService; ns.szTargetNamespace = new TCHAR[wcslen(m_szTargetNamespace)+1]; MY_ASSERT(ns.szTargetNamespace); if (!ns.szTargetNamespace) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(ns.szTargetNamespace , m_szTargetNamespace); ns.szLocal = new TCHAR[wcslen(m_szLocal)+1]; MY_ASSERT(ns.szLocal); if (!ns.szLocal) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(ns.szLocal , m_szLocal); ns.pIWbemServices = pService; mg_nsList.push_back(ns); } SysFreeString(bsNamespace); bsNamespace = NULL; if (bsLocal) { SysFreeString(bsLocal); bsLocal = NULL; } } } if (pLocator) { pLocator->Release(); pLocator = NULL; } MY_OUTPUT(L"EXIT ***** fillInNamespacePointer...", 4); return hRetRes; error: MY_ASSERT(FALSE); if (bsNamespace) SysFreeString(bsNamespace); if (bsLocal) SysFreeString(bsLocal); if (ns.szTargetNamespace) delete [] ns.szTargetNamespace; if (ns.szLocal) delete [] ns.szLocal; if (pLocator) pLocator->Release(); m_bValidLoad = FALSE; Cleanup(FALSE); return FALSE; } // // Load a single DataCollector, and everything under it. // HRESULT CDataCollector::LoadInstanceFromMOF(IWbemClassObject* pObj, CDataGroup *pParentDG, LPTSTR pszParentObjPath, BOOL bModifyPass/*FALSE*/) { GUID guid; int i, iSize; CThreshold* pThreshold; LPTSTR pszTemp; LPTSTR pszStr; HRESULT hRetRes = S_OK; //XXXXX //static count = 0; MY_OUTPUT(L"ENTER ***** CDataCollector::LoadInstanceFromMOF...", 4); // Make sure that the Thresholds are loaded properly first iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(im_bValidLoad == FALSE) // return WBEM_E_INVALID_OBJECT; return S_OK; } m_bValidLoad = TRUE; Cleanup(bModifyPass); 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; } hRetRes = GetStrProperty(pObj, L"GUID", &m_szGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; m_szParentObjPath = new TCHAR[wcslen(pszParentObjPath)+1]; MY_ASSERT(m_szParentObjPath); if (!m_szParentObjPath) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(m_szParentObjPath, pszParentObjPath); m_pParentDG = pParentDG; hRetRes = CoCreateGuid(&guid); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StringFromGUID2(guid, m_szStatusGUID, 100); hRetRes = g_pStartupSystem->AddPointerToMasterList(this); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } else { m_lIntervalCount = -1; } MY_OUTPUT2(L"m_szGUID=%s", m_szGUID, 4); // Get the Name. If it is NULL or rather blank, then we use the qualifier hRetRes = GetStrProperty(pObj, L"Name", &m_szName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; // Get the Description. If it is NULL then we use the qualifier hRetRes = GetStrProperty(pObj, L"Description", &m_szDescription); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetStrProperty(pObj, L"TargetNamespace", &m_szTargetNamespace); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetStrProperty(pObj, L"Local", &m_szLocal); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; InitContext(pObj); hRetRes = GetUint32Property(pObj, L"CollectionIntervalMsecs", &m_lCollectionIntervalMultiple); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; m_lCollectionIntervalMultiple /= 1000; hRetRes = GetUint32Property(pObj, L"CollectionTimeOut", &m_lCollectionTimeOut); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (m_lCollectionIntervalMultiple < m_lCollectionTimeOut) { m_lCollectionTimeOut = m_lCollectionIntervalMultiple; } hRetRes = GetUint32Property(pObj, L"StatisticsWindowSize", &m_lStatisticsWindowSize); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetUint8Property(pObj, L"ActiveDays", &m_iActiveDays); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; // The time format looks as follows "********0600**.******+***"; hh is hours and mm is minutes // All else is ignored. hRetRes = GetStrProperty(pObj, L"BeginTime", &pszTemp); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pszStr = wcschr(pszTemp, '.'); if (pszStr) { // Back up to look at the minute pszStr -= 2; *pszStr = '\0'; pszStr -= 2; m_lBeginMinuteTime= _wtol(pszStr); // Back up to look at the hour *pszStr = '\0'; pszStr -= 2; m_lBeginHourTime= _wtol(pszStr); } else { //XXXBad format, default to something m_lBeginMinuteTime= -1; m_lBeginHourTime= -1; } delete [] pszTemp; hRetRes = GetStrProperty(pObj, L"EndTime", &pszTemp); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pszStr = wcschr(pszTemp, '.'); if (pszStr) { // Back up to look at the minute pszStr -= 2; *pszStr = '\0'; pszStr -= 2; m_lEndMinuteTime= _wtol(pszStr); // Back up to look at the hour *pszStr = '\0'; pszStr -= 2; m_lEndHourTime= _wtol(pszStr); } else { //XXXBad format, default to something m_lEndMinuteTime= -1; m_lEndHourTime= -1; } delete [] pszTemp; hRetRes = GetStrProperty(pObj, L"TypeGUID", &m_szTypeGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetBoolProperty(pObj, L"RequireReset", &m_bRequireReset); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetBoolProperty(pObj, L"Enabled", &m_bEnabled); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetStrProperty(pObj, L"Message", &m_szMessage); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = GetStrProperty(pObj, L"ResetMessage", &m_szResetMessage); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; // // Now load all the Thresholds that are children of this one. // if (bModifyPass == FALSE) { if (m_bEnabled==FALSE || m_pParentDG->m_bEnabled==FALSE || m_pParentDG->m_bParentEnabled==FALSE) { if (m_pParentDG->m_bEnabled==FALSE || m_pParentDG->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); } hRetRes = InternalizeThresholds(); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } else { // // Set our state to enabled, or disabled and transfer to the child thresholds // if (m_bEnabled==FALSE || m_bParentEnabled==FALSE) { iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iSetParentEnabledFlag(FALSE); } } else { iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iSetParentEnabledFlag(TRUE); } } } // Setup what is needed to track statistics on each property listed // (Need to do this after the Thresholds are read in, because we may // need to insert some properties that were not in the list) hRetRes = InitPropertyStatus(pObj); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; // // Do any initialization stuff now // // Get the pointer to the namespace used in this DataCollector hRetRes = fillInNamespacePointer(); if (hRetRes != WBEM_E_INVALID_NAMESPACE) { MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } m_ulErrorCode = 0; m_ulErrorCodePrev = MAX_ULONG; m_bValidLoad = TRUE; //XXXXX #ifdef SAVE //static count = 0; if (count==3 || count==4 || count==5 || count==6 || count==11) { count++; hRetRes = WBEM_E_OUT_OF_MEMORY; goto error; } else { count++; } #endif MY_OUTPUT(L"EXIT ***** CDataCollector::LoadInstanceFromMOF...", 4); return S_OK; error: MY_ASSERT(FALSE); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } HRESULT CDataCollector::InternalizeThresholds(void) { TCHAR szTemp[1024]; HRESULT hRetRes = S_OK; ULONG uReturned; BSTR Language = NULL; BSTR Query = NULL; IWbemClassObject *pObj = NULL; IEnumWbemClassObject *pEnum = NULL; LPTSTR pszTempGUID = NULL; MY_OUTPUT(L"ENTER ***** CDataCollector::InternalizeThresholds...", 4); // Just loop through all top level Thresholds associated with the DataCollector. // Call a method of each, and have the Threshold load itself. Language = SysAllocString(L"WQL"); MY_ASSERT(Language); if (!Language) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(szTemp, L"ASSOCIATORS OF {MicrosoftHM_DataCollectorConfiguration.GUID=\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\"} WHERE ResultClass=MicrosoftHM_ThresholdConfiguration"); Query = SysAllocString(szTemp); MY_ASSERT(Query); if (!Query) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} // 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(Language); Language = NULL; // Retrieve objects in result set while (TRUE) { pObj = NULL; uReturned = 0; hRetRes = pEnum->Next(0, 1, &pObj, &uReturned); MY_ASSERT(hRetRes==S_OK || hRetRes==WBEM_S_FALSE); if (hRetRes!=S_OK && hRetRes!=WBEM_S_FALSE) { MY_HRESASSERT(hRetRes); pEnum->Release(); pEnum = NULL; return hRetRes; } if (uReturned == 0) { break; } // See if this is already read in. Need to prevent endless loop, circular references. hRetRes = GetStrProperty(pObj, L"GUID", &pszTempGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (!g_pStartupSystem->FindPointerFromGUIDInMasterList(pszTempGUID)) { // // Create the internal class to represent the Threshold // CThreshold* pThreshold = new CThreshold; MY_ASSERT(pThreshold); if (!pThreshold) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} if (m_deType == HM_PGDE) { wcscpy(szTemp, L"MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_PMDE) { wcscpy(szTemp, L"MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_PQDE) { wcscpy(szTemp, L"MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_EQDE) { wcscpy(szTemp, L"MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\\\""); } else { MY_ASSERT(FALSE); } lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\\\""); hRetRes = pThreshold->LoadInstanceFromMOF(pObj, this, szTemp); if (hRetRes==S_OK) { m_thresholdList.push_back(pThreshold); } else { MY_HRESASSERT(hRetRes); delete pThreshold; } } delete [] pszTempGUID; pszTempGUID = NULL; // Release it. pObj->Release(); pObj = NULL; } // All done pEnum->Release(); pEnum = NULL; MY_OUTPUT(L"EXIT ***** CDataCollector::InternalizeThresholds...", 4); return S_OK; error: MY_ASSERT(FALSE); if (Query) SysFreeString(Query); if (Language) SysFreeString(Language); if (pszTempGUID) delete [] pszTempGUID; if (pObj) pObj->Release(); if (pEnum) pEnum->Release(); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } // // Create an array element for each property we are interested // BOOL CDataCollector::InitContext(IWbemClassObject* pObj) { BOOL bRetValue = TRUE; #ifdef SAVE HRESULT hRes; HRESULT hRetRes; VARIANT v; VARIANT vValue; IUnknown* vUnknown; IWbemClassObject* pCO; BSTR bstrPropName = NULL; long iLBound, iUBound; LPTSTR szName; LPTSTR szValue; long lType; VariantInit(&v); bstrPropName = SysAllocString(L"Context"); if ((hRes = pObj->Get(bstrPropName, 0L, &v, NULL, NULL)) == S_OK) { if (V_VT(&v)==VT_NULL) { // MY_ASSERT(FALSE); } else { MY_ASSERT(V_VT(&v)==(VT_UNKNOWN|VT_ARRAY)); SafeArrayGetLBound(v.parray, 1, &iLBound); SafeArrayGetUBound(v.parray, 1, &iUBound); if ((iUBound - iLBound + 1) == 0) { MY_ASSERT(FALSE); } else { for (long i = iLBound; i <= iUBound; i++) { if (m_pContext == NULL) { hRes = CoCreateInstance(CLSID_WbemContext, NULL, CLSCTX_INPROC_SERVER, IID_IWbemContext, (void **)&m_pContext); if (S_OK != hRes) { MY_HRESASSERT(hRes); } } VariantInit(&vValue); vUnknown = NULL; SafeArrayGetElement(v.parray, &i, &vUnknown); pCO = (IWbemClassObject *)vUnknown; hRetRes = GetStrProperty(pCO, L"Name", &szName); MY_HRESASSERT(hRetRes); hRetRes = GetUint32Property(pCO, L"Type", &lType); MY_HRESASSERT(hRetRes); hRetRes = GetStrProperty(pCO, L"Value", &szValue); MY_HRESASSERT(hRetRes); // // Set the name value pair into the IWbemContext object // if (lType == CIM_SINT8 || lType == CIM_SINT16 || lType == CIM_CHAR16) { V_VT(&vValue) = VT_I2; V_I2(&vValue) = _wtol(szValue); } else if (lType == CIM_SINT32 || lType == CIM_UINT16 || lType == CIM_UINT32) { V_VT(&vValue) = VT_I4; V_I4(&vValue) = _wtol(szValue); } else if (lType == CIM_REAL32) { V_VT(&vValue) = VT_R4; V_R4(&vValue) = wcstod(szValue, NULL); } else if (lType == CIM_BOOLEAN) { V_VT(&vValue) = VT_BOOL; V_BOOL(&vValue) = (BOOL) _wtol(szValue); } else if (lType == CIM_SINT64 || lType == CIM_UINT64 || //XXX lType == CIM_REF || lType == CIM_STRING || lType == CIM_DATETIME) { V_VT(&vValue) = VT_BSTR; V_BSTR(&vValue) = SysAllocString(szValue); } else if (lType == CIM_REAL64) { V_VT(&vValue) = VT_R8; V_R8(&vValue) = wcstod(szValue, NULL); } else if (lType == CIM_UINT8) { V_VT(&vValue) = VT_UI1; V_UI1(&vValue) = (unsigned char) _wtoi(szValue); } else { MY_ASSERT(FALSE); } hRes = m_pContext->SetValue(szName, 0L, &vValue); if (S_OK != hRes) { MY_HRESASSERT(hRes); } VariantClear(&vValue); delete [] szName; delete [] szValue; vUnknown->Release(); } } } } else { bRetValue = FALSE; MY_HRESASSERT(hRes); } VariantClear(&v); SysFreeString(bstrPropName); #endif MY_OUTPUT(L"EXIT ***** GetStrProperty...", 1); return bRetValue; } // // Create an array element for each property we are interested // HRESULT CDataCollector::InitPropertyStatus(IWbemClassObject* pObj) { HRESULT hRetRes = S_OK; VARIANT v; BSTR vStr = NULL; BOOL bFound = FALSE; long iLBound, iUBound; PNSTRUCT pn; int i, iSize; CThreshold* pThreshold; pn.szPropertyName = NULL; pn.iRefCount = 1; pn.type = 0; VariantInit(&v); if ((hRetRes = pObj->Get(L"Properties", 0L, &v, NULL, NULL)) == S_OK) { if (V_VT(&v)==VT_NULL) { } else { MY_ASSERT(V_VT(&v)==(VT_BSTR|VT_ARRAY)); hRetRes = SafeArrayGetLBound(v.parray, 1, &iLBound); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = SafeArrayGetUBound(v.parray, 1, &iUBound); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if ((iUBound - iLBound + 1) == 0) { } else { for (long i = iLBound; i <= iUBound; i++) { vStr = NULL; hRetRes = SafeArrayGetElement(v.parray, &i, &vStr); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (_wcsicmp(vStr, L"CollectionInstanceCount") && _wcsicmp(vStr, L"CollectionErrorCode") && _wcsicmp(vStr, L"CollectionErrorDescription")) { pn.szPropertyName = new TCHAR[wcslen(vStr)+2]; MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pn.szPropertyName, vStr); m_pnList.push_back(pn); } SysFreeString(vStr); vStr = NULL; } } } } else { MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } VariantClear(&v); // // Insert all the properties used by Thresholds, that are not found in the list yet. // Refcount those that are in there already. // iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(im_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription")) { hRetRes = insertNewProperty(pThreshold->m_szPropertyName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } } pn.szPropertyName = new TCHAR[wcslen(L"CollectionInstanceCount")+2]; MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pn.szPropertyName, L"CollectionInstanceCount"); m_pnList.push_back(pn); pn.szPropertyName = new TCHAR[wcslen(L"CollectionErrorCode")+2]; MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pn.szPropertyName, L"CollectionErrorCode"); m_pnList.push_back(pn); pn.szPropertyName = new TCHAR[wcslen(L"CollectionErrorDescription")+2]; MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pn.szPropertyName, L"CollectionErrorDescription"); m_pnList.push_back(pn); return hRetRes; error: MY_ASSERT(FALSE); // VariantClear(&v); // if (pn.szPropertyName) // pn.szPropertyName = NULL; if (vStr) SysFreeString(vStr); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } // // This is the entry point for the Agents base 10 second timer. At this time we // Have each DataCollector and Threshold do its job. // BOOL CDataCollector::OnAgentInterval(void) { int i, iSize; long lIntervalCountTemp; CThreshold* pThreshold; BOOL bTimeOK; MY_OUTPUT(L"ENTER ***** CDataCollector::OnAgentInterval...", 1); // // Don't do anything if we are not loaded correctly. // Or, if a Threshold is having problems. // if (m_bValidLoad == FALSE) return FALSE; iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(im_bValidLoad == FALSE) return FALSE; } m_lPrevState = m_lCurrState; m_lNumberChanges = 0; m_szErrorDescription[0] = '\0'; // Remember that the DISABLED state overrides SCHEDULEDOUT. if ((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState==HM_DISABLED) { return TRUE; } // // Make sure that we are in a valid time to run. // bTimeOK = checkTime(); if (bTimeOK==FALSE && m_lCurrState==HM_SCHEDULEDOUT && m_bEnabled && m_bParentEnabled) { return TRUE; } else if ((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState!=HM_DISABLED || bTimeOK==FALSE && m_lCurrState!=HM_SCHEDULEDOUT) { // // Going into Scheduled Outage OR DISABLED. // What if we are going from ScheduledOut to Disabled? // Or from Disabled to ScheduledOut? // Possible transitions: // GOOD -> Disabled // GOOD -> ScheduledOut // Disabled -> ScheduledOut // ScheduledOut -> Disabled // if (m_bEnabled==FALSE || m_bParentEnabled==FALSE) { // // This is where we are transitioning into the DISABLED State // EnumDone(); if (m_lPrevState == HM_SCHEDULEDOUT) { iSize = m_thresholdList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(iSetParentScheduledOutFlag(FALSE); } } iSize = m_thresholdList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(iSetParentEnabledFlag(FALSE); } m_lCurrState = HM_DISABLED; CDataCollector::EvaluateThresholds(FALSE); m_lNumberChanges = 1; m_lIntervalCount = -1; FireEvent(FALSE); } else { // // This is where we are transitioning into the SCHEDULEDOUT State // EnumDone(); iSize = m_thresholdList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(iSetParentScheduledOutFlag(TRUE); } m_lCurrState = HM_SCHEDULEDOUT; CDataCollector::EvaluateThresholds(FALSE); m_lNumberChanges = 1; m_lIntervalCount = -1; FireEvent(FALSE); } return TRUE; } #ifdef SAVE else if (m_lCurrState==HM_DISABLED || m_lCurrState==HM_SCHEDULEDOUT) { What was in action.cpp // // Comming out of Scheduled Outage OR DISABLED. // Might be going from ScheduledOut/Disabled to Disabled, // or disabled to ScheduledOut. // m_lCurrState = HM_GOOD; FireEvent(-1, NULL, HMRES_ACTION_ENABLE); } #endif else { if (m_lPrevState == HM_SCHEDULEDOUT) { iSize = m_thresholdList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(iSetParentScheduledOutFlag(FALSE); } } if (m_lPrevState == HM_DISABLED) { iSize = m_thresholdList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(iSetParentEnabledFlag(TRUE); } } // // We are either beginning a Collection, or in the middle of one // m_lIntervalCount++; if (m_bKeepCollectingSemiSync == FALSE) { // // Here is where we need to fire an event in advance, because we are going to be in the // collecting state until we have retrieved something, or in the case of the event based // data collector, we reach the end of the collection interval. // if (m_lIntervalCount==0 || m_lIntervalCount==1) { m_lCurrState = HM_COLLECTING; m_lPrevState = m_lCurrState; iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iSetCurrState(HM_COLLECTING); } iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iFireEvent(TRUE); } FireEvent(TRUE); // // In order to smooth out the CPU utilization of the HealthMon Agent, // random offset each Data Collector. // if (m_lCollectionIntervalMultiple != 0) { if (m_lIntervalCount==1) { m_lIntervalCount = rand()%m_lCollectionIntervalMultiple; if (m_lIntervalCount == 0) m_lIntervalCount++; } else { // This case we have been forced to forego the random, and do immediate m_lIntervalCount = 1; } } } // // Beginning a Collection // Check to see if this is at an interval that we need to run at. // if ((m_lCollectionIntervalMultiple == 0) || (m_lIntervalCount!=1 && (m_lIntervalCount-1)%m_lCollectionIntervalMultiple)) { return TRUE; } CollectInstance(); // // Optomized, for when we know we have not recieved any events during the interval // if (m_bKeepCollectingSemiSync) { // This is for the case where this Data Collector might have been the only // reason for the parent data group to be in a CRITICAL state, and now, because // We do not push up the COLLECTING state, the data group might miss the change. if (m_lCurrState==HM_COLLECTING && m_lPrevState!=m_lCurrState) { m_lNumberChanges++; } return TRUE; } } else { // // Means that we still have not received all the instance(s) back yet! // Keep trying to collect the instance until the TimeOut has expired! // Also watch for when the next interval has been reached and we still have not // received the instance! // m_lCollectionTimeOutCount++; CollectInstanceSemiSync(); if (m_bKeepCollectingSemiSync) { // Check to see if we are over the TimeOut period. if (m_lCollectionTimeOutCount == m_lCollectionTimeOut) { if (m_ulErrorCode != HMRES_TIMEOUT) { lIntervalCountTemp = m_lIntervalCount; ResetState(FALSE, FALSE); m_lIntervalCount = lIntervalCountTemp; } else { EnumDone(); } MY_ASSERT(FALSE); m_ulErrorCode = HMRES_TIMEOUT; GetLatestAgentError(HMRES_TIMEOUT, m_szErrorDescription); StoreStandardProperties(); } else { // This is the case where we just return, and keep trying to collect return TRUE; } } } // // We have made it to this point because we have received all of the instance(s) // // // Evaluate the instance(s) property(s) against the threshold(s). // In the case of evnt based data collector, we do not have any events to look at // at the start, but need to wait for the end of the interval. // if (m_deType!=HM_EQDE || (m_deType==HM_EQDE && (m_lIntervalCount!=1 || m_ulErrorCode!=0))) { wcscpy(m_szDTCollectTime, m_szDTCurrTime); wcscpy(m_szCollectTime, m_szCurrTime); EvaluateThresholds(FALSE, TRUE, FALSE, FALSE); if (m_deType!=HM_EQDE) { EvaluateThresholds(FALSE, FALSE, TRUE, FALSE); } } // Event data collector will have called to send their own event if (m_deType!=HM_EQDE) { SendEvents(); FireStatisticsEvent(); } // To sync up prev and curr states for those cases that could keep producing events if (m_ulErrorCode != 0) { iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iSetPrevState(HM_CRITICAL); } } } if (m_deType == HM_EQDE) { m_lNumInstancesCollected = 0; } iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(im_bValidLoad == FALSE) { MY_ASSERT(FALSE); m_bValidLoad = FALSE; Cleanup(FALSE); break; } } m_ulErrorCodePrev = m_ulErrorCode; MY_OUTPUT(L"EXIT ***** CDataCollector::OnAgentInterval...", 1); return TRUE; } BOOL CDataCollector::SendEvents(void) { int i, iSize; long state; CThreshold* pThreshold; long lCurrChildCount = 0; if (m_bValidLoad == FALSE) return FALSE; // // See if any Thresholds were set into the RESET state, // This causes the DataCollector to set all Thresholds to the GOOD state, and // re-evaluate all thresholds. // //XXXWith this in we can implement the RESET feature, but we still need to debug fully, CheckForReset(); // // Set State of the DataCollector to the worst of everything under it // m_lNumberNormals = 0; m_lNumberWarnings = 0; m_lNumberCriticals = 0; m_lNumberChanges = 0; iSize = m_thresholdList.size(); lCurrChildCount = iSize; if (iSize != 0) { m_lCurrState = -1; for (i = 0; i < iSize ; i++) { MY_ASSERT(iGetCurrState(); MY_OUTPUT2(L"State=%d", state, 4); 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 (pThreshold->GetChange()) { MY_OUTPUT(L"CHANGE", 4); m_lNumberChanges++; } } // The disabled state of things below us did not roll up if (m_lCurrState==HM_DISABLED) { m_lCurrState = HM_GOOD; if (m_lPrevState != m_lCurrState) { m_lNumberChanges++; } } if (m_lCurrState == -1) { if (m_bEnabled==FALSE || m_bParentEnabled==FALSE) { m_lCurrState = HM_DISABLED; } else { m_lCurrState = HM_GOOD; } if (m_lPrevState != m_lCurrState) { m_lNumberChanges = 1; } } } else { m_lCurrState = HM_GOOD; if (m_lPrevState != m_lCurrState) { m_lNumberChanges = 1; } } // Finally if all else fails, and we have a DE that is RESET required, and we have an INIT // state, then set things to GOOD if (m_bRequireReset && m_lCurrState == HM_COLLECTING) { m_lNumberChanges = 0; iSize = m_thresholdList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(iSetCurrState(HM_GOOD); if (pThreshold->GetChange()) { m_lNumberChanges++; } } m_lCurrState = HM_GOOD; } if (m_lPrevChildCount!=lCurrChildCount) { if (m_lNumberChanges==0 && m_lPrevState!=m_lCurrState) { m_lNumberChanges++; } } m_lPrevChildCount = lCurrChildCount; FireEvent(FALSE); FirePerInstanceEvents(); return TRUE; } // // If there has been a change in the state then send an event // HRESULT CDataCollector::FireEvent(BOOL bForce) { HRESULT hRetRes = S_OK; IWbemClassObject* pInstance = NULL; GUID guid; HRESULT hRes; MY_OUTPUT(L"ENTER ***** CDataCollector::FireEvent...", 2); // Don't send if no-one is listening! if (g_pDataCollectorEventSink == NULL) { return S_OK; } MY_OUTPUT2(L"m_lPrevState=%d", m_lPrevState, 4); MY_OUTPUT2(L"m_lCurrState=%d", m_lCurrState, 4); MY_OUTPUT2(L"m_lNumberChanges=%d", m_lNumberChanges, 4); // A quick test to see if anything has really changed! // Proceed if there have been changes if (bForce || (m_lNumberChanges!=0 && m_lPrevState!=m_lCurrState)) { } else { return FALSE; } MY_OUTPUT2(L"EVENT: DataCollector State Change=%d", m_lCurrState, 4); // Proceed if there have been changes // yyyymmddhhmmss.ssssssXUtc; X = GMT(+ or -), Utc = 3 dig. offset from UTC.")] wcscpy(m_szDTTime, m_szDTCurrTime); wcscpy(m_szTime, m_szCurrTime); hRetRes = CoCreateGuid(&guid); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StringFromGUID2(guid, m_szStatusGUID, 100); hRes = GetHMDataCollectorStatusInstance(&pInstance, TRUE); if (FAILED(hRes)) { MY_HRESASSERT(hRes); MY_OUTPUT(L"failed to get instance!", 1); return FALSE; } else { // // Place Extrinsit event in vector for sending at end of interval. // All get sent at once. // mg_DCEventList.push_back(pInstance); } MY_OUTPUT(L"EXIT ***** CDataCollector::FireEvent...", 2); return hRetRes; error: MY_ASSERT(FALSE); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } // // Send out events for each instance that has had a change of state. // The state of each will be the worst of all. // BOOL CDataCollector::FirePerInstanceEvents(void) { long state; int i, iSize; BOOL bRetValue = TRUE; IWbemClassObject* pInstance = NULL; ACTUALINSTSTRUCT *pActualInst; long firstInstanceState = -1; MY_OUTPUT(L"ENTER ***** CDataCollector::FirePerInstanceEvents...", 2); // Don't send if no-one is listening! if (g_pDataCollectorPerInstanceEventSink == NULL) { return bRetValue; } // // We can loop through the set of collected instances and ask each Threshold // to tell us if the state has changed as far as each is concerned, for the // property they are lookin at. // iSize = m_actualInstList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iszInstanceID, (BOOL)i==0))!=-1) { if (i==0) { firstInstanceState = state; } // Update time since we had a state change wcscpy(pActualInst->szDTTime, m_szDTCurrTime); wcscpy(pActualInst->szTime, m_szCurrTime); if (GetHMDataCollectorPerInstanceStatusEvent(pActualInst->szInstanceID, pActualInst, state, &pInstance, TRUE)==S_OK) { // // Place Extrinsit event in vector for sending at end of interval. // All get sent at once. // mg_DCPerInstanceEventList.push_back(pInstance); } } } // // Do it for the three default properties // if (firstInstanceState==-1 && (state=PassBackStateIfChangedPerInstance(L"CollectionInstanceCount", FALSE))!=-1) { // Update time since we had a state change wcscpy(m_szDTCICTime, m_szDTCurrTime); wcscpy(m_szCICTime, m_szCurrTime); if (GetHMDataCollectorPerInstanceStatusEvent(L"CollectionInstanceCount", NULL, state, &pInstance, TRUE)==S_OK) { // // Place Extrinsit event in vector for sending at end of interval. // All get sent at once. // mg_DCPerInstanceEventList.push_back(pInstance); } } if (firstInstanceState==-1 && (state=PassBackStateIfChangedPerInstance(L"CollectionErrorCode", FALSE))!=-1) { // Update time since we had a state change wcscpy(m_szDTCECTime, m_szDTCurrTime); wcscpy(m_szCECTime, m_szCurrTime); if (GetHMDataCollectorPerInstanceStatusEvent(L"CollectionErrorCode", NULL, state, &pInstance, TRUE)==S_OK) { // // Place Extrinsit event in vector for sending at end of interval. // All get sent at once. // mg_DCPerInstanceEventList.push_back(pInstance); } } MY_OUTPUT(L"EXIT ***** CDataCollector::FirePerInstanceEvents...", 2); return TRUE; } long CDataCollector::PassBackStateIfChangedPerInstance(LPTSTR pszInstName, BOOL bCombineWithStandardProperties) { int i, iSize; long worstState, state; CThreshold* pThreshold; worstState = -1; iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iPassBackStateIfChangedPerInstance(pszInstName); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } } if (bCombineWithStandardProperties) { iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iPassBackStateIfChangedPerInstance(L"CollectionInstanceCount"); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } state = pThreshold->PassBackStateIfChangedPerInstance(L"CollectionErrorCode"); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } } } // May have had one Threshold go from CRITICAL to GOOD and have a change, while another // Threshold was WARNING and stayed WARNING with no change, so need to go there. if (worstState != -1) { iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iPassBackWorstStatePerInstance(pszInstName); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } } if (bCombineWithStandardProperties) { iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iPassBackWorstStatePerInstance(L"CollectionInstanceCount"); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } state = pThreshold->PassBackWorstStatePerInstance(L"CollectionErrorCode"); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } } } } return worstState; } long CDataCollector::PassBackWorstStatePerInstance(LPTSTR pszInstName, BOOL bCombineWithStandardProperties) { int i, iSize; long worstState, state; CThreshold* pThreshold; worstState = -1; iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iPassBackWorstStatePerInstance(pszInstName); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } } if (bCombineWithStandardProperties) { iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iPassBackWorstStatePerInstance(L"CollectionInstanceCount"); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } state = pThreshold->PassBackWorstStatePerInstance(L"CollectionErrorCode"); if (state != -1) { if (state==HM_DISABLED) { state = HM_GOOD; } if (state > worstState) { worstState = state; } } } } return worstState; } // Only Send statistics information on a change BOOL CDataCollector::FireStatisticsEvent(void) { BOOL bRetValue = TRUE; if (m_bValidLoad == FALSE) return FALSE; MY_OUTPUT(L"ENTER ***** CDataCollector::FireStatisticsEvent...", 2); // Don't send if no-one is listening! if (g_pDataCollectorStatisticsEventSink == NULL) { return bRetValue; } MY_OUTPUT2(L"Someone listening for statistics GUID=%s", m_szGUID, 4); fillInPropertyStatus(m_szDTCurrTime, m_szCurrTime); MY_OUTPUT(L"EXIT ***** CDataCollector::FireStatisticsEvent...", 2); return bRetValue; } BOOL CDataCollector::fillInPropertyStatus(LPTSTR szDTTime, LPTSTR szTime) { MY_ASSERT(FALSE); //Not used anymore! return TRUE; } // // Store the values for the properties that we care about. // BOOL CDataCollector::StoreValues(IWbemClassObject* pObj, LPTSTR pszInstID) { HRESULT hRetRes = S_OK; int i, iSize; int j, jSize; PNSTRUCT *ppn; INSTSTRUCT *pinst; HRESULT hRes; VARIANT v; BOOL bRetValue = TRUE; BOOL bFirstType = FALSE; BOOL bFound; CThreshold* pThreshold; VariantInit(&v); if (m_bValidLoad == FALSE) return FALSE; MY_OUTPUT(L"ENTER ***** CDataCollector::StoreValues...", 1); // // LOOP through all the properties we are suppose to collect data for into the instance(s). // If the type is set to 0 in the PropertyStat struct, then we know that it // is the first time we have seen this instance, so set it! // iSize = m_pnList.size(); if (pObj) { for (i=0; i < iSize-3; i++) { MY_ASSERT(iinstList.size(); for (j = 0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; if (!_wcsicmp(pinst->szInstanceID, pszInstID)) { bFound = TRUE; break; } } MY_ASSERT(bFound == TRUE); if (bFound == TRUE) { if (!_wcsicmp(ppn->szPropertyName, L"CollectionInstanceCount") || !_wcsicmp(ppn->szPropertyName, L"CollectionErrorCode") || !_wcsicmp(ppn->szPropertyName, L"CollectionErrorDescription")) { // Don't do for the these properties continue; } // Get the data from the perfmon property VariantInit(&v); if (ppn->type == 0) { bFirstType = TRUE; } if ((hRes = pObj->Get(ppn->szPropertyName, 0L, &v, &ppn->type, NULL)) == S_OK) { MY_OUTPUT(L"Property Get worked", 3); if (bFirstType) { ResetInst(pinst, ppn->type); } if (V_VT(&v)==VT_NULL) { MY_OUTPUT(L"NULL TYPE", 3); if (pinst->szCurrValue) { delete [] pinst->szCurrValue; pinst->szCurrValue = NULL; } if (ppn->type == CIM_STRING) { pinst->szCurrValue = new TCHAR[5]; MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pinst->szCurrValue , L""); } pinst->bNull = TRUE; } else { // We are going from collecting NULL to actually getting something if (bFirstType==FALSE && pinst->bNull==TRUE) { m_lCurrState = HM_COLLECTING; jSize = m_thresholdList.size(); for (j=0; jSetCurrState(HM_COLLECTING); } } pinst->bNull = FALSE; if (V_VT(&v)==VT_R4) { pinst->currValue.fValue = V_R4(&v); MY_ASSERT(ppn->type == CIM_REAL32); } else if (V_VT(&v)==VT_R8) { pinst->currValue.dValue = V_R8(&v); MY_ASSERT(ppn->type == CIM_REAL64); } else if (V_VT(&v)==VT_I2) { pinst->currValue.lValue = (long) V_I2(&v); } else if (V_VT(&v)==VT_I4) { if (ppn->type == CIM_UINT32) { pinst->currValue.ulValue = V_UI4(&v); } else { pinst->currValue.lValue = (long) V_I4(&v); } } // else if (V_VT(&v)==VT_UI4) // { // pinst->currValue.ulValue = (long) V_UI4(&v); // } else if (V_VT(&v)==VT_UI1) { pinst->currValue.lValue = (long) V_UI1(&v); } else if (V_VT(&v)==VT_BOOL) { pinst->currValue.lValue = (long) V_BOOL(&v); if (pinst->currValue.lValue != 0.0) { pinst->currValue.lValue = 1.0; } } else if (V_VT(&v)==VT_BSTR) { if (ppn->type == CIM_SINT64) { pinst->currValue.i64Value = _wtoi64(V_BSTR(&v)); } else if (ppn->type == CIM_UINT64) { pinst->currValue.ui64Value = 0; ReadUI64(V_BSTR(&v), pinst->currValue.ui64Value); } else { ppn->type = CIM_STRING; if (pinst->szCurrValue) { delete [] pinst->szCurrValue; } pinst->szCurrValue = new TCHAR[wcslen(V_BSTR(&v))+2]; MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pinst->szCurrValue , V_BSTR(&v)); } } else { // If for example we had a VT_BSTR | VT_ARRAY would we end up here? // We need to do something to detect arrays, and assert, or handle them??? MY_OUTPUT(L"UNKNOWN DATA TYPE", 3); ppn->type = CIM_STRING; if (pinst->szCurrValue) { delete [] pinst->szCurrValue; } pinst->szCurrValue = new TCHAR[8]; MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pinst->szCurrValue , L"UNKNOWN"); } } // // Update the min,max and average values // if (ppn->type != CIM_STRING) { CalcStatistics(pinst, ppn->type); } } else { m_ulErrorCode = hRes; GetLatestWMIError(HMRES_BADDCPROP, hRes, m_szErrorDescription); wcscat(m_szErrorDescription, L" "); wcscat(m_szErrorDescription, ppn->szPropertyName); bRetValue = FALSE; MY_OUTPUT2(L"Couldn't Get instance property=%s", ppn->szPropertyName, 4); } VariantClear(&v); } } } else { if (!_wcsicmp(pszInstID, L"CollectionInstanceCount")) { i = iSize-3; } else if (!_wcsicmp(pszInstID, L"CollectionErrorCode")) { i = iSize-2; } else if (!_wcsicmp(pszInstID, L"CollectionErrorDescription")) { i = iSize-1; } else { MY_ASSERT(FALSE); i = iSize-3; } MY_ASSERT(iinstList.size(); for (j = 0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; if (!_wcsicmp(pinst->szInstanceID, pszInstID)) { bFound = TRUE; break; } } MY_ASSERT(bFound == TRUE); if (bFound == TRUE) { // // Case where this is the special number of instances property! // if (!_wcsicmp(pszInstID, L"CollectionInstanceCount")) { ppn->type = CIM_UINT32; pinst->currValue.ulValue = m_lNumInstancesCollected; CalcStatistics(pinst, ppn->type); } else if (!_wcsicmp(pszInstID, L"CollectionErrorCode")) { ppn->type = CIM_UINT32; pinst->currValue.ulValue = m_ulErrorCode; CalcStatistics(pinst, ppn->type); } else if (!_wcsicmp(pszInstID, L"CollectionErrorDescription")) { ppn->type = CIM_STRING; if (pinst->szCurrValue) { delete [] pinst->szCurrValue; } pinst->szCurrValue = new TCHAR[wcslen(m_szErrorDescription)+2]; MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pinst->szCurrValue , m_szErrorDescription); } else { MY_ASSERT(FALSE); } } } MY_OUTPUT(L"EXIT ***** CDataCollector::StoreValues...", 1); return bRetValue; error: MY_ASSERT(FALSE); m_ulErrorCode = HMRES_NOMEMORY; GetLatestAgentError(HMRES_NOMEMORY, m_szErrorDescription); m_bValidLoad = FALSE; Cleanup(FALSE); return FALSE; } BOOL CDataCollector::StoreStandardProperties(void) { HRESULT hRetRes; if (m_bValidLoad == FALSE) return FALSE; // // Set the standard properties // hRetRes = CheckInstanceExistance(NULL, L"CollectionInstanceCount"); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StoreValues(NULL, L"CollectionInstanceCount"); CheckInstanceExistance(NULL, L"CollectionErrorCode"); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StoreValues(NULL, L"CollectionErrorCode"); CheckInstanceExistance(NULL, L"CollectionErrorDescription"); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StoreValues(NULL, L"CollectionErrorDescription"); return TRUE; error: MY_ASSERT(FALSE); m_ulErrorCode = hRetRes; GetLatestWMIError(HMRES_OBJECTNOTFOUND, hRetRes, m_szErrorDescription); m_bValidLoad = FALSE; Cleanup(FALSE); return FALSE; } BOOL CDataCollector::CalcStatistics(INSTSTRUCT *pinst, CIMTYPE type) { int i; int iSize; VALSTRUCT val; VALSTRUCT *pval; VALLIST::iterator iaVAL; union hm_datatypes value; if (type == CIM_STRING) { MY_ASSERT(FALSE); } else if (type == CIM_DATETIME) { MY_ASSERT(FALSE); } else if (type == CIM_REAL32) { if (pinst->currValue.fValue < pinst->minValue.fValue) { pinst->minValue.fValue = pinst->currValue.fValue; } if (pinst->maxValue.fValue < pinst->currValue.fValue) { pinst->maxValue.fValue = pinst->currValue.fValue; } // // Add new value to the end. // If we are over the limit of number of samples to keep, // drop the oldest. // val.value.fValue = pinst->currValue.fValue; pinst->valList.push_back(val); iSize = pinst->valList.size(); if (m_lStatisticsWindowSize < iSize) { iaVAL=pinst->valList.begin(); pinst->valList.erase(iaVAL); } // // Now calculate the average from what we have. // value.fValue = 0; iSize = pinst->valList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ivalList.size()); pval = &pinst->valList[i]; value.fValue += pval->value.fValue; } if (i==0) pinst->avgValue.fValue = value.fValue; else pinst->avgValue.fValue = value.fValue/i; } else if (type == CIM_REAL64) { if (pinst->currValue.dValue < pinst->minValue.dValue) { pinst->minValue.dValue = pinst->currValue.dValue; } if (pinst->maxValue.dValue < pinst->currValue.dValue) { pinst->maxValue.dValue = pinst->currValue.dValue; } // // Add new value to the end. // If we are over the limit of number of samples to keep, // drop the oldest. // val.value.dValue = pinst->currValue.dValue; pinst->valList.push_back(val); iSize = pinst->valList.size(); if (m_lStatisticsWindowSize < iSize) { iaVAL=pinst->valList.begin(); pinst->valList.erase(iaVAL); } // // Now calculate the average from what we have. // value.dValue = 0; iSize = pinst->valList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ivalList.size()); pval = &pinst->valList[i]; value.dValue += pval->value.dValue; } if (i==0) pinst->avgValue.dValue = value.dValue; else pinst->avgValue.dValue = value.dValue/i; } else if (type == CIM_SINT64) { if (pinst->currValue.i64Value < pinst->minValue.i64Value) { pinst->minValue.i64Value = pinst->currValue.i64Value; } if (pinst->maxValue.i64Value < pinst->currValue.i64Value) { pinst->maxValue.i64Value = pinst->currValue.i64Value; } // // Add new value to the end. // If we are over the limit of number of samples to keep, // drop the oldest. // val.value.i64Value = pinst->currValue.i64Value; pinst->valList.push_back(val); iSize = pinst->valList.size(); if (m_lStatisticsWindowSize < iSize) { iaVAL=pinst->valList.begin(); pinst->valList.erase(iaVAL); } // // Now calculate the average from what we have. // value.i64Value = 0; iSize = pinst->valList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ivalList.size()); pval = &pinst->valList[i]; value.i64Value += pval->value.i64Value; } if (i==0) pinst->avgValue.i64Value = value.i64Value; else pinst->avgValue.i64Value = value.i64Value/i; } else if (type == CIM_UINT64) { if (pinst->currValue.ui64Value < pinst->minValue.ui64Value) { pinst->minValue.ui64Value = pinst->currValue.ui64Value; } if (pinst->maxValue.ui64Value < pinst->currValue.ui64Value) { pinst->maxValue.ui64Value = pinst->currValue.ui64Value; } // // Add new value to the end. // If we are over the limit of number of samples to keep, // drop the oldest. // val.value.ui64Value = pinst->currValue.ui64Value; pinst->valList.push_back(val); iSize = pinst->valList.size(); if (m_lStatisticsWindowSize < iSize) { iaVAL=pinst->valList.begin(); pinst->valList.erase(iaVAL); } // // Now calculate the average from what we have. // value.ui64Value = 0; iSize = pinst->valList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ivalList.size()); pval = &pinst->valList[i]; value.ui64Value += pval->value.ui64Value; } if (i==0) pinst->avgValue.ui64Value = value.ui64Value; else pinst->avgValue.ui64Value = value.ui64Value/i; } else if (type == CIM_UINT32) { // Must be an integer type if (pinst->currValue.ulValue < pinst->minValue.ulValue) { pinst->minValue.ulValue = pinst->currValue.ulValue; } if (pinst->maxValue.ulValue < pinst->currValue.ulValue) { pinst->maxValue.ulValue = pinst->currValue.ulValue; } // // Add new value to the end. // If we are over the limit of number of samples to keep, // drop the oldest. // val.value.ulValue = pinst->currValue.ulValue; pinst->valList.push_back(val); iSize = pinst->valList.size(); if (m_lStatisticsWindowSize < iSize) { iaVAL=pinst->valList.begin(); pinst->valList.erase(iaVAL); } // // Now calculate the average from what we have. // value.ulValue = 0; iSize = pinst->valList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ivalList.size()); pval = &pinst->valList[i]; value.ulValue += pval->value.ulValue; } if (i==0) pinst->avgValue.ulValue = value.ulValue; else pinst->avgValue.ulValue = value.ulValue/i; } else { // Must be an integer type if (pinst->currValue.lValue < pinst->minValue.lValue) { pinst->minValue.lValue = pinst->currValue.lValue; } if (pinst->maxValue.lValue < pinst->currValue.lValue) { pinst->maxValue.lValue = pinst->currValue.lValue; } // // Add new value to the end. // If we are over the limit of number of samples to keep, // drop the oldest. // val.value.lValue = pinst->currValue.lValue; pinst->valList.push_back(val); iSize = pinst->valList.size(); if (m_lStatisticsWindowSize < iSize) { iaVAL=pinst->valList.begin(); pinst->valList.erase(iaVAL); } // // Now calculate the average from what we have. // value.lValue = 0; iSize = pinst->valList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(ivalList.size()); pval = &pinst->valList[i]; value.lValue += pval->value.lValue; } if (i==0) pinst->avgValue.lValue = value.lValue; else pinst->avgValue.lValue = value.lValue/i; } return TRUE; } BOOL CDataCollector::EvaluateThresholds(BOOL bIgnoreReset, BOOL bSkipStandard/*=FALSE*/, BOOL bSkipOthers/*=FALSE*/, BOOL bDoThresholdSkipClean/*=TRUE*/) { LPTSTR pszPropertyName; int iSize; int jSize; int i; int j; CThreshold* pThreshold; PNSTRUCT *ppn = NULL; BOOL bFound = FALSE; INSTSTRUCT *pinst; if (m_bValidLoad == FALSE) return FALSE; // // For each threshold associated with this DataCollector, find the property status // structure, and have the threshold evaluate against the current values. // iSize = m_thresholdList.size(); for (i = 0; i < iSize; i++) { MY_ASSERT(im_bValidLoad == FALSE) break; pszPropertyName = pThreshold->GetPropertyName(); if (bSkipStandard && (!_wcsicmp(pszPropertyName, L"CollectionInstanceCount") || !_wcsicmp(pszPropertyName, L"CollectionErrorCode") || !_wcsicmp(pszPropertyName, L"CollectionErrorDescription"))) { if (bDoThresholdSkipClean) pThreshold->SkipClean(); continue; } if (bSkipOthers && (_wcsicmp(pszPropertyName, L"CollectionInstanceCount") && _wcsicmp(pszPropertyName, L"CollectionErrorCode") && _wcsicmp(pszPropertyName, L"CollectionErrorDescription"))) { if (bDoThresholdSkipClean) pThreshold->SkipClean(); continue; } jSize = m_pnList.size(); for (j = 0; j < jSize ; j++) { MY_ASSERT(jszPropertyName, pszPropertyName)) { bFound = TRUE; break; } } // // If the type is still equal to zero, that means that the threshold is probably looking // at a property that does not exist. // Also remember that if we are transitioning to DISABLED, or SCHEDULEDOUT we need to // go into the Threshold evaluation do disable them. // if ((m_lCurrState==HM_DISABLED || m_lCurrState==HM_SCHEDULEDOUT) || ((m_ulErrorCode==0 || (m_ulErrorCode!=0 && !wcscmp(pszPropertyName, L"CollectionErrorCode"))) && (bFound && ppn->type!=0))) { // // Also need to watch for case where we can't do evaluation yet. // If AVERAGE is used, then wait until full window of samples has been collected. // If difference, then must wait for the second one. // if (pThreshold->m_bUseDifference) { if (m_lIntervalCount < 2) { continue; } } else if (pThreshold->m_bUseAverage) { // Need to find out how many samples we have MY_ASSERT(ppn); if (ppn->instList.size()) { pinst = &ppn->instList[0]; if (pinst->valList.size() < m_lStatisticsWindowSize) { continue; } } else { } } // If this threshold has already been violated and the RequireReset is TRUE // then we don't need to test for re-arm. if (bIgnoreReset == TRUE) { if (pThreshold->GetCurrState() != HM_RESET) { pThreshold->SetCurrState(HM_COLLECTING); pThreshold->SetBackPrev(ppn); pThreshold->OnAgentInterval(&m_actualInstList, ppn, m_bRequireReset); } } else { pThreshold->OnAgentInterval(&m_actualInstList, ppn, m_bRequireReset); } } else { if (pThreshold->m_bEnabled==FALSE || pThreshold->m_bParentEnabled==FALSE || pThreshold->m_bParentScheduledOut) { pThreshold->OnAgentInterval(&m_actualInstList, ppn, m_bRequireReset); } else if (m_ulErrorCode!=0) { // Case where had an error in the collection process that needs to take priority. pThreshold->SetCurrState(HM_CRITICAL, m_ulErrorCode!=m_ulErrorCodePrev, HMRES_DCUNKNOWN); pThreshold->FireEvent(m_ulErrorCode!=m_ulErrorCodePrev); } else if (ppn->type==0) { // Having zero instances is not a crime if we are certain types of DataColectors. if (m_lNumInstancesCollected>0) { // Case where the property to collect did not exist m_ulErrorCode = HMRES_BADTHRESHPROP; pThreshold->SetCurrState(HM_CRITICAL, m_ulErrorCode!=m_ulErrorCodePrev, HMRES_BADTHRESHPROP); pThreshold->FireEvent(m_ulErrorCode!=m_ulErrorCodePrev); GetLatestAgentError(HMRES_BADTHRESHPROP, m_szErrorDescription); wcscat(m_szErrorDescription, L" "); wcscat(m_szErrorDescription, pszPropertyName); StoreValues(NULL, L"CollectionErrorCode"); StoreValues(NULL, L"CollectionErrorDescription"); } else { pThreshold->SetCurrState(HM_GOOD, m_ulErrorCode!=m_ulErrorCodePrev, HMRES_DCUNKNOWN); pThreshold->FireEvent(m_ulErrorCode!=m_ulErrorCodePrev); } } else { } } } return TRUE; } HRESULT CDataCollector::SendHMDataCollectorStatusInstance(IWbemObjectSink* pSink, LPTSTR pszGUID) { MY_ASSERT(pSink!=NULL); // // Is this the one we are looking for? // if (!_wcsicmp(m_szGUID, pszGUID)) { // // Don't do anything if we are not loaded correctly. // //XXX if (m_bValidLoad == FALSE) //XXX return WBEM_E_INVALID_OBJECT; return SendHMDataCollectorStatusInstances(pSink); } else { return WBEM_S_DIFFERENT; } } HRESULT CDataCollector::SendHMDataCollectorStatusInstances(IWbemObjectSink* pSink) { HRESULT hRes = S_OK; IWbemClassObject* pInstance = NULL; MY_OUTPUT(L"ENTER ***** SendHMDataCollectorStatusInstances...", 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 = GetHMDataCollectorStatusInstance(&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_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1); } pInstance->Release(); pInstance = NULL; } else { MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1); } MY_OUTPUT(L"EXIT ***** SendHMDataCollectorStatusInstances...", 2); return hRes; } HRESULT CDataCollector::SendHMDataCollectorPerInstanceStatusInstance(IWbemObjectSink* pSink, LPTSTR pszGUID) { MY_ASSERT(pSink!=NULL); // // Is this the one we are looking for? // if (!_wcsicmp(m_szGUID, pszGUID)) { if (m_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; return SendHMDataCollectorPerInstanceStatusInstances(pSink); } else { return WBEM_S_DIFFERENT; } } // This one is for enumeration of all Instances outside of the hierarchy. // Just the flat list. HRESULT CDataCollector::SendHMDataCollectorPerInstanceStatusInstances(IWbemObjectSink* pSink) { HRESULT hRes; long state; int i, iSize; BOOL bRetValue = TRUE; IWbemClassObject* pInstance = NULL; ACTUALINSTSTRUCT *pActualInst; long firstInstanceState = -1; MY_OUTPUT(L"ENTER ***** CDataCollector::SendHMDataCollectorPerInstanceStatusInstance...", 2); if (m_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; if (pSink == NULL) { MY_OUTPUT(L"-Invalid Sink", 1); return WBEM_E_FAILED; } // // We can loop through the set of collected instances and ask each Threshold // to tell us if the state has changed as far as each is concerned, for the // property they are lookin at. // iSize = m_actualInstList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iszInstanceID, (BOOL)i==0); if (state==-1) state = HM_COLLECTING; if (i==0) { firstInstanceState = state; } hRes = GetHMDataCollectorPerInstanceStatusEvent(pActualInst->szInstanceID, pActualInst, state, &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_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1); } pInstance->Release(); pInstance = NULL; } else { MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1); } } // // Do it for the three default properties // if (firstInstanceState==-1) { state = PassBackWorstStatePerInstance(L"CollectionInstanceCount", FALSE); if (state==-1) state = HM_COLLECTING; hRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionInstanceCount", NULL, state, &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_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1); } pInstance->Release(); pInstance = NULL; } else { MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1); } } if (firstInstanceState==-1) { state = PassBackWorstStatePerInstance(L"CollectionErrorCode", FALSE); if (state==-1) state = HM_COLLECTING; hRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionErrorCode", NULL, state, &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_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1); } pInstance->Release(); pInstance = NULL; } else { MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1); } } #ifdef SAVE state = PassBackWorstStatePerInstance(L"CollectionErrorDescription"); if (state==-1) state = HM_COLLECTING; hRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionErrorDescription", NULL, state, &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_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1); } pInstance->Release(); pInstance = NULL; } else { MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1); } #endif MY_OUTPUT(L"EXIT ***** CDataCollector::FirePerInstanceEvents...", 2); return S_OK; } HRESULT CDataCollector::SendHMDataCollectorStatisticsInstance(IWbemObjectSink* pSink, LPTSTR pszGUID) { MY_ASSERT(pSink!=NULL); // // Is this the one we are looking for? // if (!_wcsicmp(m_szGUID, pszGUID)) { if (m_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; return SendHMDataCollectorStatisticsInstances(pSink); } else { return WBEM_S_DIFFERENT; } } HRESULT CDataCollector::SendHMDataCollectorStatisticsInstances(IWbemObjectSink* pSink) { HRESULT hRes = S_OK; MY_OUTPUT(L"ENTER ***** SendHMDataCollectorStatisticsInstances...", 2); if (m_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; if (pSink == NULL) { MY_OUTPUT(L"CDC::SendInitialHMMachStatInstances-Invalid Sink", 1); return WBEM_E_FAILED; } hRes = GetHMDataCollectorStatisticsInstances(m_szDTCollectTime, m_szCollectTime); MY_OUTPUT(L"EXIT ***** SendHMDataCollectorStatisticsInstances...", 2); return hRes; } HRESULT CDataCollector::SendHMThresholdStatusInstances(IWbemObjectSink* pSink) { int i; int iSize; CThreshold *pThreshold; PNSTRUCT *ppn = NULL; BOOL bFound = FALSE; MY_OUTPUT(L"ENTER ***** SendHMThresholdStatusInstances...", 1); // Have all Thresholds of this DataCollector send their status iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iSendHMThresholdStatusInstances(pSink); } MY_OUTPUT(L"EXIT ***** SendHMThresholdStatusInstances...", 1); return S_OK; } HRESULT CDataCollector::SendHMThresholdStatusInstance(IWbemObjectSink* pSink, LPTSTR pszGUID) { int i; int iSize; CThreshold *pThreshold; PNSTRUCT *ppn = NULL; HRESULT hRetRes = S_OK; MY_OUTPUT(L"ENTER ***** SendHMThresholdStatusInstance...", 1); // Try to find the one that needs sending iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iSendHMThresholdStatusInstance(pSink, pszGUID); if (hRetRes==S_OK) { return S_OK; } else if (hRetRes!=WBEM_S_DIFFERENT) { return hRetRes; } } MY_OUTPUT(L"EXIT ***** SendHMThresholdStatusInstance...", 1); return WBEM_S_DIFFERENT; } HRESULT CDataCollector::GetHMDataCollectorStatusInstance(IWbemClassObject** ppInstance, BOOL bEventBased) { TCHAR szTemp[1024]; IWbemClassObject* pClass = NULL; BSTR bsString = NULL; HRESULT hRetRes = S_OK; DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH + 2; TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 2]; MY_OUTPUT(L"ENTER ***** GetHMSystemStatusInstance...", 1); if (bEventBased) { bsString = SysAllocString(L"MicrosoftHM_DataCollectorStatusEvent"); MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} } else { bsString = SysAllocString(L"MicrosoftHM_DataCollectorStatus"); MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} } hRetRes = g_pIWbemServices->GetObject(bsString, 0L, NULL, &pClass, NULL); SysFreeString(bsString); bsString = NULL; if (FAILED(hRetRes)) { return hRetRes; } hRetRes = pClass->SpawnInstance(0, ppInstance); pClass->Release(); pClass = NULL; if (FAILED(hRetRes)) return hRetRes; if (m_bValidLoad == FALSE) { hRetRes = PutStrProperty(*ppInstance, L"GUID", m_szGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"ParentGUID", m_pParentDG->m_szGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutUint32Property(*ppInstance, L"State", HM_CRITICAL); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (g_hResLib == NULL || !LoadString(g_hResLib, HMRES_DC_LOADFAIL, szTemp, 1024)) { wcscpy(szTemp, L"Data Collector failed to load."); } hRetRes = PutStrProperty(*ppInstance, L"Message", szTemp); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (GetComputerName(szComputerName, &dwNameLen)) { hRetRes = PutStrProperty(*ppInstance, L"SystemName", szComputerName); } else { hRetRes = PutStrProperty(*ppInstance, L"SystemName", L"LocalMachine"); } hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTTime); hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szTime); hRetRes = PutStrProperty(*ppInstance, L"Name", L"..."); } else { hRetRes = PutStrProperty(*ppInstance, L"GUID", m_szGUID); hRetRes = PutStrProperty(*ppInstance, L"ParentGUID", m_pParentDG->m_szGUID); hRetRes = PutStrProperty(*ppInstance, L"Name", m_szName); if (GetComputerName(szComputerName, &dwNameLen)) { hRetRes = PutStrProperty(*ppInstance, L"SystemName", szComputerName); } else { hRetRes = PutStrProperty(*ppInstance, L"SystemName", L"LocalMachine"); } hRetRes = PutUint32Property(*ppInstance, L"State", m_lCurrState); hRetRes = PutUint32Property(*ppInstance, L"CollectionInstanceCount", m_lNumInstancesCollected); hRetRes = PutUUint32Property(*ppInstance, L"CollectionErrorCode", m_ulErrorCode); hRetRes = PutStrProperty(*ppInstance, L"CollectionErrorDescription", m_szErrorDescription); hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTTime); hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szTime); hRetRes = PutStrProperty(*ppInstance, L"StatusGUID", m_szStatusGUID); if (m_lCurrState==HM_SCHEDULEDOUT) { if (g_hResLib == NULL || !LoadString(g_hResLib, HMRES_OUTAGE, szTemp, 1024)) { wcscpy(szTemp, L"Data Collector in Scheduled Outage State"); } hRetRes = PutStrProperty(*ppInstance, L"Message", szTemp); } else if (m_lCurrState==HM_DISABLED) { if (g_hResLib == NULL || !LoadString(g_hResLib, HMRES_DISABLE, szTemp, 1024)) { wcscpy(szTemp, L"Data Collector in Disabled State"); } hRetRes = PutStrProperty(*ppInstance, L"Message", szTemp); } MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } MY_OUTPUT(L"EXIT ***** GetHMSystemStatusInstance...", 1); return hRetRes; error: MY_ASSERT(FALSE); if (bsString) SysFreeString(bsString); if (pClass) pClass->Release(); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } HRESULT CDataCollector::GetHMDataCollectorStatisticsInstances(LPTSTR szDTTime, LPTSTR szTime) { HRESULT hRetRes = S_OK; PNSTRUCT *ppn = NULL; INSTSTRUCT *pinst = NULL; int i, iSize; int j, jSize; TCHAR szTemp[128] = {0}; IWbemClassObject* pClass = NULL; IWbemClassObject* pInstance = NULL; BSTR bsString = NULL; DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH + 2; TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 2]; int rc = 0; char buffer[50]; iSize = m_pnList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iinstList.size(); for (j=0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; bsString = SysAllocString(L"MicrosoftHM_DataCollectorStatistics"); MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} hRetRes = g_pIWbemServices->GetObject(bsString, 0L, NULL, &pClass, NULL); SysFreeString(bsString); bsString = NULL; if (FAILED(hRetRes)) { return hRetRes; } hRetRes = pClass->SpawnInstance(0, &pInstance); pClass->Release(); pClass = NULL; if (FAILED(hRetRes)) return hRetRes; hRetRes = PutStrProperty(pInstance, L"GUID", m_szGUID); if (GetComputerName(szComputerName, &dwNameLen)) { hRetRes = PutStrProperty(pInstance, L"SystemName", szComputerName); } else { hRetRes = PutStrProperty(pInstance, L"SystemName", L"LocalMachine"); } hRetRes = PutStrProperty(pInstance, L"PropertyName", ppn->szPropertyName); hRetRes = PutStrProperty(pInstance, L"InstanceName", pinst->szInstanceID); hRetRes = PutStrProperty(pInstance, L"TimeGeneratedGMT", szDTTime); hRetRes = PutStrProperty(pInstance, L"LocalTimeFormatted", szTime); if (pinst->bNull==TRUE) { hRetRes = PutStrProperty(pInstance, L"CurrentValue", L"NULL"); } else if (ppn->type==CIM_STRING || ppn->type==CIM_DATETIME) { if (pinst->szCurrValue) { hRetRes = PutStrProperty(pInstance, L"CurrentValue", pinst->szCurrValue); } else { hRetRes = PutStrProperty(pInstance, L"CurrentValue", L""); } } else if (ppn->type == CIM_REAL32) { _gcvt((double)pinst->currValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp); } else if (ppn->type == CIM_REAL64) { _gcvt(pinst->currValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp); } else if (ppn->type == CIM_SINT64) { _i64tow(pinst->currValue.i64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp); } else if (ppn->type == CIM_UINT64) { _ui64tow(pinst->currValue.ui64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp); } else if (ppn->type == CIM_UINT32) { // Must be an integer type _ultow(pinst->currValue.ulValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp); } else { // Must be an integer type _ltow(pinst->currValue.lValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp); } if (pinst->bNull==TRUE) { hRetRes = PutStrProperty(pInstance, L"MinValue", L""); hRetRes = PutStrProperty(pInstance, L"MaxValue", L""); hRetRes = PutStrProperty(pInstance, L"AvgValue", L""); } else if (ppn->type==CIM_STRING || ppn->type==CIM_DATETIME) { hRetRes = PutStrProperty(pInstance, L"MinValue", L""); hRetRes = PutStrProperty(pInstance, L"MaxValue", L""); hRetRes = PutStrProperty(pInstance, L"AvgValue", L""); } else if (ppn->type == CIM_REAL32) { _gcvt((double)pinst->minValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp); _gcvt((double)pinst->maxValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp); _gcvt((double)pinst->avgValue.fValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp); } else if (ppn->type == CIM_REAL64) { _gcvt(pinst->minValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp); _gcvt(pinst->maxValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp); _gcvt(pinst->avgValue.dValue, 7, buffer); rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128); szTemp[rc] = NULL; hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp); } else if (ppn->type == CIM_SINT64) { _i64tow(pinst->minValue.i64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp); _i64tow(pinst->maxValue.i64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp); _i64tow(pinst->avgValue.i64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp); } else if (ppn->type == CIM_UINT64) { _ui64tow(pinst->minValue.ui64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp); _ui64tow(pinst->maxValue.ui64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp); _ui64tow(pinst->avgValue.ui64Value, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp); } else if (ppn->type == CIM_UINT32) { // Must be an integer type _ultow(pinst->minValue.ulValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp); _ultow(pinst->maxValue.ulValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp); _ultow(pinst->avgValue.ulValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp); } else { // Must be an integer type _ltow(pinst->minValue.lValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp); _ltow(pinst->maxValue.lValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp); _ltow(pinst->avgValue.lValue, szTemp, 10 ); hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp); } MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; // If we do not have all our samples, then don't show the average yet if (pinst->valList.size() < m_lStatisticsWindowSize) { hRetRes = PutStrProperty(pInstance, L"AvgValue", L"-"); } mg_DCStatsInstList.push_back(pInstance); } } return S_OK; error: MY_ASSERT(FALSE); if (bsString) SysFreeString(bsString); if (pClass) pClass->Release(); iSize = mg_DCStatsInstList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iRelease(); } mg_DCStatsInstList.clear(); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } long CDataCollector::GetCurrState(void) { return m_lCurrState; } HRESULT CDataCollector::FindAndModDataCollector(BSTR szGUID, IWbemClassObject* pObj) { HRESULT hRetRes = S_OK; // // Is this us we are looking for? // if (!_wcsicmp(m_szGUID, szGUID)) { hRetRes = LoadInstanceFromMOF(pObj, NULL, L"", TRUE); return hRetRes; } return WBEM_S_DIFFERENT; } HRESULT CDataCollector::FindAndModThreshold(BSTR szGUID, IWbemClassObject* pObj) { TCHAR szTemp[1024]; HRESULT hRetRes = S_OK; int i, iSize; CThreshold* pThreshold; if (m_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; // // Look at Threshold of this DataDataCollector // iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(im_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; hRetRes = pThreshold->FindAndModThreshold(szGUID, pObj); if (hRetRes==S_OK) { wcsncpy(szTemp, pThreshold->m_szPropertyName, 1023); szTemp[1023] = '\0'; // Check to see if the Threshold is looking at a different property! if (_wcsicmp(szTemp, pThreshold->m_szPropertyName)) { if (_wcsicmp(szTemp, L"CollectionInstanceCount") && _wcsicmp(szTemp, L"CollectionErrorCode") && _wcsicmp(szTemp, L"CollectionErrorDescription")) { propertyNotNeeded(szTemp); } if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription")) { hRetRes = insertNewProperty(pThreshold->m_szPropertyName); if (hRetRes != S_OK) return hRetRes; } } ResetState(TRUE, TRUE); return S_OK; } else if (hRetRes!=WBEM_S_DIFFERENT) { MY_ASSERT(FALSE); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } } return WBEM_S_DIFFERENT; } HRESULT CDataCollector::AddThreshold(BSTR szParentGUID, BSTR szChildGUID) { int i, iSize; TCHAR szTemp[1024]; CThreshold* pThreshold = NULL; IWbemClassObject *pObj = NULL; BSTR Path = NULL; HRESULT hRetRes; LPTSTR pszTempGUID = NULL; // // Are we the parent DataGroup that we want to add under? // if (!_wcsicmp(m_szGUID, szParentGUID)) { // // First check to see if is in there already! // iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iGetGUID())) { return S_OK; } } // // Add in the Threshold // wcscpy(szTemp, L"MicrosoftHM_ThresholdConfiguration.GUID=\""); lstrcat(szTemp, szChildGUID); lstrcat(szTemp, L"\""); Path = SysAllocString(szTemp); MY_ASSERT(Path); if (!Path) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} hRetRes = GetWbemObjectInst(&g_pIWbemServices, Path, NULL, &pObj); if (!pObj) { SysFreeString(Path); Path = NULL; return hRetRes; } TCHAR msgbuf[1024]; wsprintf(msgbuf, L"ASSOCIATION: Threshold to DataCollector ParentDCGUID=%s ChildTGUID=%s", szParentGUID, szChildGUID); MY_OUTPUT(msgbuf, 4); // See if this is already read in. Need to prevent endless loop, circular references. hRetRes = GetStrProperty(pObj, L"GUID", &pszTempGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (!g_pStartupSystem->FindPointerFromGUIDInMasterList(pszTempGUID)) { // // Create the internal class to represent the DataGroup // pThreshold = new CThreshold; MY_ASSERT(pThreshold); if (!pThreshold) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} if (m_deType == HM_PGDE) { wcscpy(szTemp, L"MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_PMDE) { wcscpy(szTemp, L"MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_PQDE) { wcscpy(szTemp, L"MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_EQDE) { wcscpy(szTemp, L"MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\\\""); } lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\\\""); if (pThreshold->LoadInstanceFromMOF(pObj, this, szTemp)==S_OK) { if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription")) { hRetRes = insertNewProperty(pThreshold->m_szPropertyName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } // // Get Threshold and DataCollector synced up. Plus we may have been in the middle of a // collection interval as this came in. // ResetState(TRUE, TRUE); m_thresholdList.push_back(pThreshold); } else { delete pThreshold; } } delete [] pszTempGUID; pszTempGUID = NULL; pObj->Release(); pObj = NULL; SysFreeString(Path); Path = NULL; return S_OK; } return WBEM_S_DIFFERENT; error: MY_ASSERT(FALSE); if (pszTempGUID) delete [] pszTempGUID; if (Path) SysFreeString(Path); if (pObj) pObj->Release(); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } LPTSTR CDataCollector::GetGUID(void) { return m_szGUID; } BOOL CDataCollector::ResetResetThresholdStates(void) { int i, iSize; CThreshold* pThreshold; iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iResetResetThreshold(); } return TRUE; } BOOL CDataCollector::GetChange(void) { if (m_lNumberChanges!=0 && m_lPrevState!=m_lCurrState) { return TRUE; } else { return FALSE; } } // // Called By the Delete method that the HMSystemConfiguration class exposes. // We search down the hierarchy until we find what we need to delete. // We are only search down form where we are, as the object above already verified // that we are not what was being looked for. // HRESULT CDataCollector::FindAndDeleteByGUID(LPTSTR pszGUID) { BOOL bDeleted = FALSE; int i, iSize; CThreshold* pThreshold; RLIST::iterator iaR; // // Traverse the complete hierarchy to find the object to delete. // iSize = m_thresholdList.size(); iaR=m_thresholdList.begin(); for (i=0; im_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; if (!_wcsicmp(pszGUID, pThreshold->GetGUID())) { if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription")) { propertyNotNeeded(pThreshold->m_szPropertyName); } pThreshold->DeleteThresholdConfig(); delete pThreshold; m_thresholdList.erase(iaR); bDeleted = TRUE; TCHAR msgbuf[1024]; wsprintf(msgbuf, L"DELETION: TGUID=%s", pszGUID); MY_OUTPUT(msgbuf, 4); // // Get Threshold and DataCollector synced up. Plus we may have been in the middle of a // collection interval as this came in. // ResetState(TRUE, TRUE); break; } } if (bDeleted == FALSE) { return S_FALSE; } else { return S_OK; } } // // HMSystemConfiguration class exposes this method. // HRESULT CDataCollector::FindAndEnableByGUID(LPTSTR pszGUID, BOOL bEnable) { BOOL bFound = FALSE; int i, iSize; CThreshold* pThreshold; // // Traverse the complete hierarchy to find the object to enable/disable. // iSize = m_thresholdList.size(); for (i=0; iGetGUID())) { bFound = TRUE; break; } } if (bFound == FALSE) { return S_FALSE; } else { return S_OK; } } // // HMSystemConfiguration class exposes this method. // // Get rid of the data that was collected, so we can be clean, // just as if we just started running. // // HRESULT CDataCollector::ResetState(BOOL bPreserveThresholdStates, BOOL bDoImmediate) { CThreshold* pThreshold; PNSTRUCT *ppn = NULL; INSTSTRUCT *pinst; InstIDSTRUCT *pInstID; int i, j; int iSize, jSize; ACTUALINSTSTRUCT *pActualInst; MY_OUTPUT(L"ENTER ***** CDataCollector::ResetState...", 1); if (m_bEnabled==FALSE || m_bParentEnabled==FALSE) { return S_OK; } CleanupSemiSync(); m_ulErrorCodePrev = MAX_ULONG; m_lIntervalCount = 0; if (bDoImmediate) { m_lIntervalCount = -1; } else { m_lIntervalCount = 0; } m_lCollectionTimeOutCount = 0; m_lNumInstancesCollected = 0; if (bPreserveThresholdStates == FALSE) { m_lCurrState = HM_COLLECTING; } m_bKeepCollectingSemiSync = FALSE; iSize = m_pnList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iinstList.size(); for (j = 0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; if (pinst->szCurrValue) { delete [] pinst->szCurrValue; } if (pinst->szInstanceID) { delete [] pinst->szInstanceID; } pinst->valList.clear(); } ppn->instList.clear(); } iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iClearInstList(); if (bPreserveThresholdStates == FALSE) { pThreshold->SetCurrState(HM_COLLECTING); } } iSize = m_actualInstList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iszInstanceID) { delete [] pActualInst->szInstanceID; } if (pActualInst->pInst) { pActualInst->pInst->Release(); pActualInst->pInst = NULL; } } m_actualInstList.clear(); // // Need this for sure with PMDC, does it adversly affect other DataCollectors // iSize = m_instIDList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iszInstanceIDPropertyName; } m_instIDList.clear(); MY_OUTPUT(L"EXIT ***** CDataCollector::ResetState...", 1); return S_OK; } // // HMSystemConfiguration class exposes this method. // HRESULT CDataCollector::ResetStatistics(void) { INSTSTRUCT *pinst; PNSTRUCT *ppn; int i, j; int iSize, jSize; MY_OUTPUT(L"ENTER ***** CDataCollector::ResetStatistics...", 1); if (m_bEnabled==FALSE || m_bParentEnabled==FALSE) { return S_OK; } iSize = m_pnList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iinstList.size(); for (j = 0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; if (pinst->szCurrValue) { delete [] pinst->szCurrValue; } pinst->szCurrValue = NULL; ResetInst(pinst, ppn->type); pinst->valList.clear(); } } EvaluateNow(TRUE); MY_OUTPUT(L"EXIT ***** CDataCollector::ResetStatistics...", 1); return S_OK; } // // HMSystemConfiguration class exposes this method. // Set the increment count back to zero temporarily, so it will // run at the next second interval, then set back! // HRESULT CDataCollector::EvaluateNow(BOOL bDoImmediate) { MY_OUTPUT(L"ENTER ***** CDataCollector::EvaluateNow...", 1); if (m_bValidLoad == FALSE) return WBEM_E_INVALID_OBJECT; EnumDone(); if (bDoImmediate) { m_lIntervalCount = -1; } else { m_lIntervalCount = 0; } m_lCollectionTimeOutCount = 0; if (m_deType != HM_EQDE) { m_lNumInstancesCollected = 0; } MY_OUTPUT(L"EXIT ***** CDataCollector::EvaluateNow...", 1); return S_OK; } BOOL CDataCollector::SetParentEnabledFlag(BOOL bEnabled) { int i, iSize; CThreshold* pThreshold; m_bParentEnabled = bEnabled; if (m_bEnabled==FALSE || m_bParentEnabled==FALSE) { } else { m_lIntervalCount = 0; } // // Now traverse children and call for everything below // iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iSetParentEnabledFlag(m_bEnabled && m_bParentEnabled); } return TRUE; } BOOL CDataCollector::Init(void) { MY_OUTPUT(L"ENTER ***** CDataCollector::Init...", 1); m_lIntervalCount = 0; m_lCollectionTimeOutCount = 0; m_lNumberNormals = 0; m_lNumberWarnings = 0; m_lNumberCriticals = 0; m_lNumberChanges = 0; m_lNumInstancesCollected = 0; m_lCurrState = HM_COLLECTING; m_lPrevState = HM_COLLECTING; m_ulErrorCode = 0; m_ulErrorCodePrev = MAX_ULONG; m_lCollectionTimeOut = 0; m_szGUID = NULL; m_szParentObjPath = NULL; m_pParentDG = NULL; m_szName = NULL; m_szDescription = NULL; m_szUserName = NULL; m_szPassword = NULL; m_szTargetNamespace = NULL; m_szLocal = NULL; m_szTypeGUID = NULL; m_pContext = NULL; m_pCallResult = NULL; m_bKeepCollectingSemiSync = FALSE; m_bEnabled = TRUE; m_bParentEnabled = TRUE; m_pIWbemServices = NULL; m_lCollectionIntervalMultiple = 60; m_lStatisticsWindowSize = 6; m_iActiveDays = 0; m_lBeginHourTime = 0; m_lBeginMinuteTime = 0; m_lEndHourTime = 0; m_lEndMinuteTime = 0; m_lTypeGUID = 0; m_bRequireReset = FALSE; m_bReplicate = FALSE; m_lId = 0; m_szErrorDescription[0] = '\0'; m_szMessage = NULL; m_szResetMessage = NULL; m_lPrevChildCount = 0; // yyyymmddhhmmss.ssssssXUtc; X = GMT(+ or -), Utc = 3 dig. offset from UTC.")] wcscpy(m_szTime, m_szCurrTime); wcscpy(m_szCollectTime, m_szCurrTime); wcscpy(m_szCICTime, m_szCurrTime); wcscpy(m_szCECTime, m_szCurrTime); wcscpy(m_szDTTime, m_szDTCurrTime); wcscpy(m_szDTCollectTime, m_szDTCurrTime); wcscpy(m_szDTCICTime, m_szDTCurrTime); wcscpy(m_szDTCECTime, m_szDTCurrTime); MY_OUTPUT(L"EXIT ***** CDataCollector::Init...", 1); return TRUE; } BOOL CDataCollector::Cleanup(BOOL bSavePrevSettings) { PNSTRUCT *ppn; INSTSTRUCT *pinst; int i, iSize; int j, jSize; CThreshold* pThreshold; InstIDSTRUCT *pInstID; ACTUALINSTSTRUCT *pActualInst; IWbemClassObject* pInstance = NULL; MY_OUTPUT(L"ENTER ***** CDataCollector::Cleanup...", 1); 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_szMessage) { delete [] m_szMessage; m_szMessage = NULL; } if (m_szResetMessage) { delete [] m_szResetMessage; m_szResetMessage = NULL; } if (m_szUserName) { delete [] m_szUserName; m_szUserName = NULL; } if (m_szPassword) { delete [] m_szPassword; m_szPassword = NULL; } if (m_szTargetNamespace) { delete [] m_szTargetNamespace; m_szTargetNamespace = NULL; } if (m_szLocal) { delete [] m_szLocal; m_szLocal = NULL; } iSize = m_instIDList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iszInstanceIDPropertyName; } m_instIDList.clear(); if (m_szTypeGUID) { delete [] m_szTypeGUID; m_szTypeGUID = NULL; } if (m_pContext != NULL) { m_pContext->Release(); m_pContext = NULL; } if (m_pCallResult != NULL) { m_pCallResult->Release(); m_pCallResult = NULL; } if (bSavePrevSettings) { ResetState(TRUE, TRUE); // // Need to also get rid of the Property names, // As ResetState does not do that. // iSize = m_pnList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iszPropertyName) { delete [] ppn->szPropertyName; } } m_pnList.clear(); } else { iSize = m_pnList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iszPropertyName) { delete [] ppn->szPropertyName; } jSize = ppn->instList.size(); for (j = 0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; if (pinst->szCurrValue) { delete [] pinst->szCurrValue; } if (pinst->szInstanceID) { delete [] pinst->szInstanceID; } pinst->valList.clear(); } ppn->instList.clear(); } m_pnList.clear(); // // Clean up everything under this DataCollector // if (m_bValidLoad == TRUE) { iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iszInstanceID) { delete [] pActualInst->szInstanceID; } if (pActualInst->pInst) { pActualInst->pInst->Release(); pActualInst->pInst = NULL; } } m_actualInstList.clear(); } if (m_bValidLoad == FALSE) { EnumDone(); if (GetHMDataCollectorStatusInstance(&pInstance, TRUE) == S_OK) { mg_DCEventList.push_back(pInstance); } } MY_OUTPUT(L"EXIT ***** CDataCollector::Cleanup...", 1); return TRUE; } #ifdef SAVE // // For when moving from one parent to another // BOOL CDataCollector::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_DATAGROUP) { wcscpy(szNewTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_DataGroupConfiguration.GUID=\""); } else { MY_ASSERT(FALSE); } lstrcat(szNewTemp, pNewParentBase->m_szGUID); lstrcat(szNewTemp, L"\""); // // Delete the association from my parent to me. // if (m_deType == HM_PGDE) { wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\""); } else if (m_deType == HM_PMDE) { wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\""); } else if (m_deType == HM_PQDE) { wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\""); } else if (m_deType == HM_EQDE) { wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHealthMonitor:MicrosoftHM_EventQueryDataCollectorConfiguration.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) { } 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; } DeleteDEConfig(TRUE); if (pNewParentBase->m_hmStatusType == HMSTATUS_DATAGROUP) { wcscpy(szNewTemp, L"MicrosoftHM_DataGroupConfiguration.GUID=\\\""); lstrcat(szNewTemp, pNewParentBase->m_szGUID); lstrcat(szNewTemp, L"\\\""); } else { MY_ASSERT(FALSE); } if (m_szParentObjPath) { delete [] m_szParentObjPath; } m_szParentObjPath = new TCHAR[wcslen(szNewTemp)+1]; wcscpy(m_szParentObjPath, szNewTemp); m_pParentDG = (CDataGroup *) pNewParentBase; MY_OUTPUT(L"EXIT ***** CDataGroup::ModifyAssocForMove...", 4); return TRUE; } #endif BOOL CDataCollector::ReceiveNewChildForMove(CBase *pBase) { //XXX seems to be some code missing here, //did we clean up from the old place things like m_pnList, and add to the new one if it is a //new property. // Like what we do in -> CDataCollector::AddThreshold() MY_ASSERT(FALSE); MY_ASSERT(pBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR); m_thresholdList.push_back((CThreshold *)pBase); // (CThreshold *)pBase->SetParentEnabledFlag(m_bEnabled); if (_wcsicmp(((CThreshold *)pBase)->m_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(((CThreshold *)pBase)->m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(((CThreshold *)pBase)->m_szPropertyName, L"CollectionErrorDescription")) { insertNewProperty(((CThreshold *)pBase)->m_szPropertyName); // MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } // // Get Threshold and DataCollector synced up. Plus we may have been in the middle of a // collection interval as this came in. // ResetState(TRUE, TRUE); return TRUE; } BOOL CDataCollector::DeleteChildFromList(LPTSTR pszGUID) { int i, iSize; CThreshold* pThreshold; RLIST::iterator iaR; BOOL bFound = FALSE; iSize = m_thresholdList.size(); iaR=m_thresholdList.begin(); for (i=0; im_bValidLoad == FALSE) return FALSE; if (!_wcsicmp(pszGUID, pThreshold->GetGUID())) { if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") && _wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription")) { propertyNotNeeded(pThreshold->m_szPropertyName); } m_thresholdList.erase(iaR); bFound = TRUE; break; } } return bFound; } BOOL CDataCollector::DeleteDEConfig(BOOL bDeleteAssocOnly) { int i, iSize; CThreshold* pThreshold; HRESULT hRetRes = S_OK; TCHAR szTemp[1024]; BSTR instName = NULL; MY_OUTPUT(L"ENTER ***** CDataCollector::DeleteDEConfig...", 4); MY_OUTPUT2(L"m_szGUID=%s", m_szGUID, 4); // // Delete the association from my parent to me. // if (m_deType == HM_PGDE) { wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_PMDE) { wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_PQDE) { wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\\\""); } else if (m_deType == HM_EQDE) { wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_EventQueryDataCollectorConfiguration.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) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} if ((hRetRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK) { SysFreeString(instName); instName = NULL; wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_DataCollectorConfiguration.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) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} if ((hRetRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK) { // MY_HRESASSERT(hRes); } } SysFreeString(instName); instName = NULL; if (bDeleteAssocOnly) { return TRUE; } // // Delete our exact instance // wcscpy(szTemp, L"MicrosoftHM_DataCollectorConfiguration.GUID=\""); lstrcat(szTemp, m_szGUID); lstrcat(szTemp, L"\""); instName = SysAllocString(szTemp); MY_ASSERT(instName); if (!instName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} if ((hRetRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK) { // MY_HRESASSERT(hRes); } SysFreeString(instName); instName = NULL; // // Traverse the complete hierarchy and delete // iSize = m_thresholdList.size(); for (i=0; iDeleteThresholdConfig(); delete pThreshold; } m_thresholdList.clear(); // // Get rid of any associations to actions for this // g_pSystem->DeleteAllConfigActionAssoc(m_szGUID); MY_OUTPUT(L"EXIT ***** CDataCollector::DeleteDEConfig...", 4); return TRUE; error: MY_ASSERT(FALSE); if (instName) SysFreeString(instName); m_bValidLoad = FALSE; Cleanup(FALSE); return FALSE; } BOOL CDataCollector::DeleteDEInternal(void) { int i, iSize; CThreshold* pThreshold; MY_OUTPUT(L"ENTER ***** CDataCollector::DeleteDEInternal...", 4); // // Traverse the complete hierarchy and delete // iSize = m_thresholdList.size(); for (i=0; iDeleteAllConfigActionAssoc(m_szGUID); MY_OUTPUT(L"EXIT ***** CDataCollector::DeleteDEInternal...", 4); return TRUE; } HRESULT CDataCollector::FindAndCopyByGUID(LPTSTR pszGUID, ILIST* pConfigList, LPTSTR *pszOriginalParentGUID) { int i, iSize; CThreshold* pThreshold; HRESULT hRetRes = S_OK; // // Find what to copy // iSize = m_thresholdList.size(); for (i=0; iGetGUID())) { hRetRes = pThreshold->Copy(pConfigList, NULL, NULL); *pszOriginalParentGUID = m_szGUID; return hRetRes; } } return WBEM_S_DIFFERENT; } HRESULT CDataCollector::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; int i, iSize; CThreshold* pThreshold; BSTR Language = NULL; BSTR Query = NULL; IEnumWbemClassObject *pEnum; ULONG uReturned; IWbemContext *pCtx = 0; LPTSTR pszParentPath = NULL; LPTSTR pszChildPath = NULL; LPTSTR pStr; HRESULT hRetRes = S_OK; MY_OUTPUT(L"ENTER ***** CDataCollector::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) { return hRetRes; } // // Clone the instance, and change the GUID // hRetRes = pInst->Clone(&pInstCopy); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; 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(Language); 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; } // // Add in all children // iSize = m_thresholdList.size(); for (i=0; iCopy(pConfigList, m_szGUID, szNewGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } pInst->Release(); pInst = NULL; MY_OUTPUT(L"EXIT ***** CDataCollector::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; m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } CBase *CDataCollector::GetParentPointerFromGUID(LPTSTR pszGUID) { int i, iSize; CThreshold* pThreshold; BOOL bFound = FALSE; CBase *pBase; iSize = m_thresholdList.size(); for (i=0; iGetGUID())) { pBase = pThreshold; bFound = TRUE; break; } } if (bFound == TRUE) { return pBase; } else { return NULL; } } CBase *CDataCollector::FindImediateChildByName(LPTSTR pszName) { int i, iSize; CThreshold* pThreshold; BOOL bFound = FALSE; CBase *pBase; iSize = m_thresholdList.size(); for (i=0; im_bValidLoad == FALSE) return NULL; if (!_wcsicmp(pszName, pThreshold->m_szName)) { pBase = pThreshold; bFound = TRUE; break; } } if (bFound == TRUE) { return pBase; } else { return NULL; } } BOOL CDataCollector::GetNextChildName(LPTSTR pszChildName, LPTSTR pszOutName) { TCHAR szTemp[1024]; TCHAR szIndex[1024]; int i, iSize; BOOL bFound; CThreshold* pThreshold; int index; // We are here because we know that one exists already with the same name. // So, lets start off trying to guess what the next name should be and get one. index = 0; bFound = TRUE; while (bFound == TRUE) { wcscpy(szTemp, pszChildName); _itow(index, szIndex, 10); lstrcat(szTemp, L" "); lstrcat(szTemp, szIndex); bFound = FALSE; iSize = m_thresholdList.size(); for (i=0; im_bValidLoad == FALSE) break; if (!_wcsicmp(szTemp, pThreshold->m_szName)) { bFound = TRUE; break; } } index++; } wcscpy(pszOutName, szTemp); return TRUE; } CBase *CDataCollector::FindPointerFromName(LPTSTR pszName) { int i, iSize; CThreshold* pThreshold; BOOL bFound = FALSE; CBase *pBase; iSize = m_thresholdList.size(); for (i=0; iGetGUID())) { pBase = pThreshold; bFound = TRUE; break; } } if (bFound == TRUE) { return pBase; } else { return NULL; } } HRESULT CDataCollector::GetInstanceID(IWbemClassObject* pObj, LPTSTR *pszID) { HRESULT hRetRes = NULL; TCHAR szTemp[1024]; LPTSTR pszTemp = NULL; InstIDSTRUCT InstID; SAFEARRAY *psaNames = NULL; BSTR PropName = NULL; long lLower, lUpper; int i, iSize; InstIDSTRUCT *pInstID; if (m_bValidLoad == FALSE) return FALSE; iSize = m_instIDList.size(); if (iSize == 0) { hRetRes = pObj->GetNames(NULL, WBEM_FLAG_KEYS_ONLY | WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames); if (SUCCEEDED(hRetRes)) { // Get the number of properties. hRetRes = SafeArrayGetLBound(psaNames, 1, &lLower); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = SafeArrayGetUBound(psaNames, 1, &lUpper); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if ((lUpper - lLower + 1) == 0) { InstID.szInstanceIDPropertyName = new TCHAR[3]; MY_ASSERT(InstID.szInstanceIDPropertyName); if (!InstID.szInstanceIDPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(InstID.szInstanceIDPropertyName , L"@"); m_instIDList.push_back(InstID); } else { // For each property... for (long k=lLower; k<=lUpper; k++) { // Get this property. hRetRes = SafeArrayGetElement(psaNames, &k, &PropName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (SUCCEEDED(hRetRes)) { InstID.szInstanceIDPropertyName = new TCHAR[wcslen(PropName)+2]; MY_ASSERT(InstID.szInstanceIDPropertyName); if (!InstID.szInstanceIDPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(InstID.szInstanceIDPropertyName , PropName); SysFreeString(PropName); PropName = NULL; m_instIDList.push_back(InstID); } } } SafeArrayDestroy(psaNames); psaNames = NULL; } } MY_ASSERT(m_instIDList.size()); // // Add it as a new instance if necessary // All PropertyNames have the same list of instances. // Just look at the first PropertyName, and search through // its list of instances. // MY_ASSERT(m_instIDList.size()); pInstID = &m_instIDList[0]; if (!wcscmp(pInstID->szInstanceIDPropertyName, L"@")) { *pszID = new TCHAR[3]; MY_ASSERT(pszID); if (!pszID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(*pszID , L"@"); } else { szTemp[0] = '\0'; iSize = m_instIDList.size(); for (i=0; i < iSize; i++) { if (i != 0) wcscat(szTemp, L";"); MY_ASSERT(iszInstanceIDPropertyName, &pszTemp); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; wcscat(szTemp, pszTemp); delete [] pszTemp; pszTemp = NULL; } *pszID = new TCHAR[wcslen(szTemp)+2]; MY_ASSERT(pszID); if (!pszID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(*pszID , szTemp); } return hRetRes; error: MY_ASSERT(FALSE); if (PropName) SysFreeString(PropName); if (pszTemp) delete [] pszTemp; if (psaNames) SafeArrayDestroy(psaNames); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } // // Adds new instances that have not been seen before, and makes ones seen alread as // needed again. If pObj is NULL, that means it is one of the special Agent provided // properties - CollectionInstanceCount, CollectionErrorCode or CollectionErrorDescription. // HRESULT CDataCollector::CheckInstanceExistance(IWbemClassObject *pObj, LPTSTR pszInstanceID) { HRESULT hRetRes = S_OK; BOOL bFound; PNSTRUCT *ppn; INSTSTRUCT *pinst; int i, j, iSize, jSize; int foundInstID; CThreshold *pThreshold; IRSSTRUCT *pirs; INSTSTRUCT inst; LPTSTR pszPropertyName; // BOOL bRetValue; if (m_bValidLoad == FALSE) return FALSE; // Just need to look at the instance list of the first property to tell if the // instance has been seen yet. if (pObj) { bFound = FALSE; iSize = m_pnList.size(); if (4 <= iSize) { i = 0; MY_ASSERT(iinstList.size(); for (j=0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; if (!_wcsicmp(pinst->szInstanceID, pszInstanceID)) { bFound = TRUE; foundInstID = j; break; } } } } else { bFound = FALSE; iSize = m_pnList.size(); if (3 <= iSize) { if (!_wcsicmp(pszInstanceID, L"CollectionInstanceCount")) { i = iSize-3; } else if (!_wcsicmp(pszInstanceID, L"CollectionErrorCode")) { i = iSize-2; } else if (!_wcsicmp(pszInstanceID, L"CollectionErrorDescription")) { i = iSize-1; } else { MY_ASSERT(FALSE); i = iSize-3; } MY_ASSERT(iinstList.size(); for (j=0; j < jSize ; j++) { MY_ASSERT(jinstList.size()); pinst = &ppn->instList[j]; if (!_wcsicmp(pinst->szInstanceID, pszInstanceID)) { bFound = TRUE; foundInstID = j; break; } } } } if (bFound == FALSE) { // Add an instance to each property name. // Only add the CollectionInstanceCount instance to the CollectionInstanceCount property. // and the CollectionErrorCode instance to the CollectionErrorCode property. // and the CollectionErrorDescription instance to the CollectionErrorDescription property. iSize = m_pnList.size(); if (pObj) { for (i=0; i < iSize-3; i++) { MY_ASSERT(itype); inst.bNull = FALSE; inst.bNeeded = TRUE; ppn->instList.push_back(inst); } // Also add instance for all thresholds under this DataCollector // Only add the CollectionInstanceCount instance to the Threshold looking at // the CollectionInstanceCount property. Same for CollectionErrorCode and CollectionErrorDescription. iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iGetPropertyName(); if (_wcsicmp(pszPropertyName, L"CollectionInstanceCount") && _wcsicmp(pszPropertyName, L"CollectionErrorCode") && _wcsicmp(pszPropertyName, L"CollectionErrorDescription")) { hRetRes = pThreshold->AddInstance(pszInstanceID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } } } else { if (!_wcsicmp(pszInstanceID, L"CollectionInstanceCount")) { i = iSize-3; } else if (!_wcsicmp(pszInstanceID, L"CollectionErrorCode")) { i = iSize-2; } else if (!_wcsicmp(pszInstanceID, L"CollectionErrorDescription")) { i = iSize-1; } else { MY_ASSERT(FALSE); i = iSize-3; } MY_ASSERT(itype); inst.bNull = FALSE; inst.bNeeded = TRUE; ppn->instList.push_back(inst); // Also add instance for all thresholds under this DataCollector // Only add the CollectionInstanceCount instance to the Threshold looking at // the CollectionInstanceCount property. Same for CollectionErrorCode and CollectionErrorDescription. iSize = m_thresholdList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iGetPropertyName(); if (!_wcsicmp(pszPropertyName, pszInstanceID) || !_wcsicmp(pszPropertyName, pszInstanceID) || !_wcsicmp(pszPropertyName, pszInstanceID)) { hRetRes = pThreshold->AddInstance(pszInstanceID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } } } } else { iSize = m_pnList.size(); if (pObj) { for (i=0; i < iSize-3 ; i++) { MY_ASSERT(iinstList.size()); pinst = &ppn->instList[foundInstID]; pinst->bNull = FALSE; pinst->bNeeded = TRUE; } //Also for all thresholds under this DataCollector iSize = m_thresholdList.size(); for (i=0; i < iSize ; i++) { MY_ASSERT(iGetPropertyName(); if (_wcsicmp(pszPropertyName, L"CollectionInstanceCount") && _wcsicmp(pszPropertyName, L"CollectionErrorCode") && _wcsicmp(pszPropertyName, L"CollectionErrorDescription")) { MY_ASSERT(foundInstIDm_irsList.size()); pirs = &pThreshold->m_irsList[foundInstID]; pirs->bNeeded = TRUE; } } } else { if (!_wcsicmp(pszInstanceID, L"CollectionInstanceCount")) { i = iSize-3; } else if (!_wcsicmp(pszInstanceID, L"CollectionErrorCode")) { i = iSize-2; } else if (!_wcsicmp(pszInstanceID, L"CollectionErrorDescription")) { i = iSize-1; } else { MY_ASSERT(FALSE); i = iSize-3; } MY_ASSERT(iinstList.size()); pinst = &ppn->instList[foundInstID]; pinst->bNull = FALSE; pinst->bNeeded = TRUE; // Also for all thresholds under this DataCollector // Only add the CollectionInstanceCount instance to the Threshold looking at // the CollectionInstanceCount property. Same for CollectionErrorCode and CollectionErrorDescription. iSize = m_thresholdList.size(); for (i=0; i < iSize ; i++) { MY_ASSERT(iGetPropertyName(); if (!_wcsicmp(pszPropertyName, pszInstanceID) || !_wcsicmp(pszPropertyName, pszInstanceID) || !_wcsicmp(pszPropertyName, pszInstanceID)) { MY_ASSERT(foundInstIDm_irsList.size()); pirs = &pThreshold->m_irsList[foundInstID]; pirs->bNeeded = TRUE; } } } } if (pObj) { hRetRes = CheckActualInstanceExistance(pObj, pszInstanceID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } return hRetRes; error: MY_ASSERT(FALSE); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } HRESULT CDataCollector::CheckActualInstanceExistance(IWbemClassObject *pObj, LPTSTR pszInstanceID) { HRESULT hRetRes = S_OK; BOOL bFound; int i, iSize; INSTSTRUCT inst; ACTUALINSTSTRUCT actualInst; ACTUALINSTSTRUCT *pActualInst; if (m_bValidLoad == FALSE) return FALSE; // // Check the list of actual instances that the Data Collector is collecting. // We keep around the latest one(s) for the DataCollector. // bFound = FALSE; iSize = m_actualInstList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iszInstanceID, pszInstanceID)) { pActualInst->bNeeded = TRUE; if (pActualInst->pInst) { pActualInst->pInst->Release(); pActualInst->pInst = NULL; } hRetRes = pObj->Clone(&pActualInst->pInst); if (FAILED(hRetRes)) { MY_HRESASSERT(hRetRes); return hRetRes; } bFound = TRUE; break; } } if (bFound == FALSE) { actualInst.szInstanceID = new TCHAR[wcslen(pszInstanceID)+2]; MY_ASSERT(actualInst.szInstanceID); if (!actualInst.szInstanceID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(actualInst.szInstanceID, pszInstanceID); actualInst.pInst = NULL; actualInst.bNeeded = TRUE; wcscpy(actualInst.szDTTime, m_szDTCurrTime); wcscpy(actualInst.szTime, m_szCurrTime); hRetRes = pObj->Clone(&actualInst.pInst); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; m_actualInstList.push_back(actualInst); } return hRetRes; error: MY_ASSERT(FALSE); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } BOOL CDataCollector::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; } BOOL CDataCollector::SetCurrState(HM_STATE state, BOOL bCheckChanges/*FALSE*/) { m_lCurrState = state; return TRUE; } BOOL CDataCollector::checkTime(void) { BOOL bTimeOK; SYSTEMTIME st; // system time // // Make sure that we are in a valid time to run. // NULL (-1) means run all the time. // bTimeOK = FALSE; if (m_bEnabled==TRUE && m_bParentEnabled==TRUE) { GetLocalTime(&st); bTimeOK = FALSE; // Check the Day of the Week if (!(m_iActiveDays&(1< st.wHour) || ((m_lEndHourTime == st.wHour) && m_lEndMinuteTime > st.wMinute)) { bTimeOK = TRUE; } else if ((st.wHour > m_lBeginHourTime) || ((st.wHour == m_lBeginHourTime) && st.wMinute >= m_lBeginMinuteTime)) { bTimeOK = TRUE; } } } return bTimeOK; } HRESULT CDataCollector::GetHMDataCollectorPerInstanceStatusEvent(LPTSTR pszInstanceID, ACTUALINSTSTRUCT *pActualInst, long state, IWbemClassObject** ppInstance, BOOL bEventBased) { HRESULT hRetRes = S_OK; GUID guid; BSTR bsName = NULL; VARIANT v; IWbemClassObject* pEmbeddedDataCollectorInst = NULL; IWbemClassObject* pClass = NULL; BSTR bsString = NULL; DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH + 2; TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 2]; TCHAR szStatusGUID[1024]; VariantInit(&v); MY_OUTPUT(L"ENTER *****CDataCollector::GetHMDataCollectorPerInstanceStatusEvent...", 1); if (bEventBased) { bsString = SysAllocString(L"MicrosoftHM_DataCollectorPerInstanceStatusEvent"); MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} } else { bsString = SysAllocString(L"MicrosoftHM_DataCollectorPerInstanceStatus"); MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} } hRetRes = g_pIWbemServices->GetObject(bsString, 0L, NULL, &pClass, NULL); SysFreeString(bsString); bsString = NULL; if (FAILED(hRetRes)) { MY_HRESASSERT(hRetRes); return hRetRes; } hRetRes = pClass->SpawnInstance(0, ppInstance); pClass->Release(); pClass = NULL; if (FAILED(hRetRes)) { MY_HRESASSERT(hRetRes); return hRetRes; } hRetRes = CoCreateGuid(&guid); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StringFromGUID2(guid, szStatusGUID, 100); hRetRes = PutStrProperty(*ppInstance, L"GUID", m_szGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"InstanceName", pszInstanceID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"Name", m_szName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"ParentGUID", m_pParentDG->m_szGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutUint32Property(*ppInstance, L"State", state); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutUint32Property(*ppInstance, L"CollectionInstanceCount", m_lNumInstancesCollected); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutUUint32Property(*ppInstance, L"CollectionErrorCode", m_ulErrorCode); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"CollectionErrorDescription", m_szErrorDescription); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"StatusGUID", szStatusGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (pActualInst) { hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", pActualInst->szDTTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", pActualInst->szTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } else if (!wcscmp(pszInstanceID, L"CollectionInstanceCount")) { hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTCICTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szCICTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } else if (!wcscmp(pszInstanceID, L"CollectionErrorCode")) { hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTCECTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szCECTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } else { MY_ASSERT(FALSE); hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTCurrTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szCurrTime); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } // Get the computer name of the machine if (GetComputerName(szComputerName, &dwNameLen)) { hRetRes = PutStrProperty(*ppInstance, L"SystemName", szComputerName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } else { hRetRes = PutStrProperty(*ppInstance, L"SystemName", L"LocalMachine"); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } if (state != HM_GOOD) { hRetRes = PutStrProperty(*ppInstance, L"Message", m_szMessage); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } else { hRetRes = PutStrProperty(*ppInstance, L"Message", m_szResetMessage); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } if (pActualInst) { hRetRes = FormatMessage(*ppInstance, pActualInst->pInst); } else { hRetRes = FormatMessage(*ppInstance, NULL); } //XXX //Make sure that this code is correct if (pActualInst && hRetRes==S_OK && m_bValidLoad) { hRetRes = pActualInst->pInst->Clone(&pEmbeddedDataCollectorInst); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; if (pEmbeddedDataCollectorInst) { bsName = SysAllocString(L"EmbeddedCollectedInstance"); MY_ASSERT(bsName); if (!bsName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} VariantInit(&v); V_VT(&v) = VT_UNKNOWN; V_UNKNOWN(&v) = (IUnknown*)pEmbeddedDataCollectorInst; (V_UNKNOWN(&v))->AddRef(); hRetRes = (*ppInstance)->Put(bsName, 0L, &v, 0L); VariantClear(&v); SysFreeString(bsName); bsName = NULL; MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pEmbeddedDataCollectorInst->Release(); pEmbeddedDataCollectorInst = NULL; } } MY_OUTPUT(L"EXIT *****CDataCollector::GetHMDataCollectorPerInstanceStatusEvent...", 1); return hRetRes; error: MY_ASSERT(FALSE); if (bsString) SysFreeString(bsString); if (bsName) SysFreeString(bsName); if (pClass) pClass->Release(); if (pEmbeddedDataCollectorInst) pEmbeddedDataCollectorInst->Release(); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } // // Do string replacement for the Message property // HRESULT CDataCollector::FormatMessage(IWbemClassObject* pIRSInstance, IWbemClassObject *pEmbeddedInstance) { HRESULT hRetRes = S_OK; BSTR PropName = NULL; LPTSTR pszMsg = NULL; SAFEARRAY *psaNames = NULL; long lNum; LPTSTR pszDest = NULL; LPTSTR pszUpperMsg = NULL; LPTSTR pszNewMsg = NULL; LPTSTR pStr = NULL; LPTSTR pStr2 = NULL; LPTSTR pStrStart = NULL; TOKENSTRUCT tokenElmnt; TOKENSTRUCT *pTokenElmnt; REPSTRUCT repElmnt; REPSTRUCT *pRepElmnt; REPSTRUCT *pRepElmnt2; REPLIST replacementList; int i, iSize, iSizeNeeded, j; long lLower, lUpper; static TOKENLIST tokenList; TOKENLIST embeddedInstTokenList; if (m_bValidLoad == FALSE) return FALSE; // // 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. // hRetRes = pIRSInstance->GetNames(NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames); if (SUCCEEDED(hRetRes)) { // 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. hRetRes = SafeArrayGetElement(psaNames, &l, &PropName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; // 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"EmbeddedCollectedInstance")) { SysFreeString(PropName); PropName = NULL; continue; } tokenElmnt.szOrigToken = new TCHAR[wcslen(PropName)+1]; MY_ASSERT(tokenElmnt.szOrigToken); if (!tokenElmnt.szOrigToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(tokenElmnt.szOrigToken, PropName); tokenElmnt.szToken = new TCHAR[wcslen(PropName)+3]; MY_ASSERT(tokenElmnt.szToken); if (!tokenElmnt.szToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} 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); psaNames = NULL; } } // // Populate the list of properties on the embedded instance that came from the // Data Collector. // if (pEmbeddedInstance) { MY_ASSERT(pEmbeddedInstance); hRetRes = pEmbeddedInstance->GetNames(NULL, WBEM_FLAG_ALWAYS, NULL, &psaNames); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; // 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. hRetRes = SafeArrayGetElement(psaNames, &l, &PropName); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; tokenElmnt.szOrigToken = new TCHAR[wcslen(PropName)+1]; MY_ASSERT(tokenElmnt.szOrigToken); if (!tokenElmnt.szOrigToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(tokenElmnt.szOrigToken, PropName); tokenElmnt.szToken = new TCHAR[wcslen(PropName)+29]; MY_ASSERT(tokenElmnt.szToken); if (!tokenElmnt.szToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(tokenElmnt.szToken, L"%"); wcscat(tokenElmnt.szToken, L"EmbeddedCollectedInstance."); wcscat(tokenElmnt.szToken, PropName); wcscat(tokenElmnt.szToken, L"%"); _wcsupr(tokenElmnt.szToken); tokenElmnt.szReplacementText = NULL; embeddedInstTokenList.push_back(tokenElmnt); SysFreeString(PropName); PropName = NULL; } SafeArrayDestroy(psaNames); psaNames = NULL; } // // 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; pTokenElmnt->szReplacementText = NULL; } if (!wcscmp(pTokenElmnt->szToken, L"%TESTCONDITION%")) { hRetRes = GetUint32Property(pIRSInstance, pTokenElmnt->szOrigToken, &lNum); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; MY_ASSERT(lNum<9); pStr = new TCHAR[wcslen(conditionLocStr[lNum])+1]; MY_ASSERT(pStr); if (!pStr) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pStr, conditionLocStr[lNum]); } else if (!wcscmp(pTokenElmnt->szToken, L"%STATE%")) { hRetRes = GetUint32Property(pIRSInstance, pTokenElmnt->szOrigToken, &lNum); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; MY_ASSERT(lNum<10); pStr = new TCHAR[wcslen(stateLocStr[lNum])+1]; MY_ASSERT(pStr); if (!pStr) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pStr, stateLocStr[lNum]); } else { hRetRes = GetAsStrProperty(pIRSInstance, pTokenElmnt->szOrigToken, &pStr); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; } pTokenElmnt->szReplacementText = pStr; } // // Get the replacement strings for this instance - Embedded // iSize = embeddedInstTokenList.size(); for (i=0; iszReplacementText != NULL) { delete [] pTokenElmnt->szReplacementText; pTokenElmnt->szReplacementText = NULL; } MY_ASSERT(pEmbeddedInstance); hRetRes = GetAsStrProperty(pEmbeddedInstance, pTokenElmnt->szOrigToken, &pStr); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pTokenElmnt->szReplacementText = pStr; } // // 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!!! hRetRes = GetStrProperty(pIRSInstance, L"Message", &pszMsg); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; pszUpperMsg = _wcsdup(pszMsg); MY_ASSERT(pszUpperMsg); if (!pszUpperMsg) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} _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]; MY_ASSERT(pszNewMsg); if (!pszNewMsg) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} *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; pszNewMsg = NULL; replacementList.clear(); } else { PutStrProperty(pIRSInstance, L"Message", pszMsg); } delete [] pszMsg; pszMsg = NULL; free(pszUpperMsg); pszUpperMsg = NULL; // 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 hRetRes; error: MY_ASSERT(FALSE); if (PropName) SysFreeString(PropName); if (psaNames) SafeArrayDestroy(psaNames); if (pszNewMsg) delete [] pszNewMsg; if (pszMsg) delete [] pszMsg; if (pszUpperMsg) free(pszUpperMsg); iSize = embeddedInstTokenList.size(); for (i=0; iszToken) delete [] pTokenElmnt->szToken; if (pTokenElmnt->szOrigToken) delete [] pTokenElmnt->szOrigToken; if (pTokenElmnt->szReplacementText) delete [] pTokenElmnt->szReplacementText; } embeddedInstTokenList.clear(); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } BOOL CDataCollector::SendReminderActionIfStateIsSame(IWbemObjectSink* pActionEventSink, IWbemObjectSink* pActionTriggerEventSink, IWbemClassObject* pActionInstance, IWbemClassObject* pActionTriggerInstance, unsigned long ulTriggerStates) { HRESULT hRetRes = S_OK; IWbemClassObject* pInstance = NULL; BSTR bsName = NULL; VARIANT v; long state; int i, iSize; BOOL bRetValue = TRUE; ACTUALINSTSTRUCT *pActualInst; long firstInstanceState = -1; GUID guid; TCHAR szStatusGUID[100]; VariantInit(&v); MY_OUTPUT(L"ENTER ***** CDataCollector::SendReminderActionIfStateIsSame...", 2); if (m_bValidLoad == FALSE) return FALSE; // // We can loop through the set of collected instances and ask each Threshold // to tell us if the state has changed as far as each is concerned, for the // property they are lookin at. // iSize = m_actualInstList.size(); for (i=0; i < iSize; i++) { MY_ASSERT(iszInstanceID, (BOOL)i==0); if (state==-1) state = HM_COLLECTING; if (i==0) { firstInstanceState = state; } // Check to see if still in the desired state if (!(ulTriggerStates&(1<szInstanceID, pActualInst, state, &pInstance, TRUE); if (SUCCEEDED(hRetRes)) { PutUint32Property(pActionTriggerInstance, L"State", m_lCurrState); bsName = SysAllocString(L"EmbeddedStatusEvent"); MY_ASSERT(bsName); if (!bsName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} VariantInit(&v); V_VT(&v) = VT_UNKNOWN; V_UNKNOWN(&v) = (IUnknown*)pInstance; (V_UNKNOWN(&v))->AddRef(); hRetRes = (pActionTriggerInstance)->Put(bsName, 0L, &v, 0L); VariantClear(&v); SysFreeString(bsName); bsName = NULL; MY_HRESASSERT(hRetRes); if (pActionEventSink) { hRetRes = CoCreateGuid(&guid); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StringFromGUID2(guid, szStatusGUID, 100); hRetRes = PutStrProperty(pActionInstance, L"StatusGUID", szStatusGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = pActionEventSink->Indicate(1, &pActionInstance); //WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver. if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY) { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"Failed on Indicate!", 4); } } if (pActionTriggerEventSink) { hRetRes = pActionTriggerEventSink->Indicate(1, &pActionTriggerInstance); //WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver. if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY) { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"Failed on Indicate!", 4); } } pInstance->Release(); pInstance = NULL; } else { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"failed to get instance!", 4); } } // // Do it for the three default properties // if (firstInstanceState==-1) { state = PassBackWorstStatePerInstance(L"CollectionInstanceCount", FALSE); if (state==-1) state = HM_COLLECTING; // Check to see if still in the desired state if ((ulTriggerStates&(1<AddRef(); hRetRes = (pActionTriggerInstance)->Put(bsName, 0L, &v, 0L); VariantClear(&v); SysFreeString(bsName); bsName = NULL; MY_HRESASSERT(hRetRes); if (pActionEventSink) { hRetRes = CoCreateGuid(&guid); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StringFromGUID2(guid, szStatusGUID, 100); hRetRes = PutStrProperty(pActionInstance, L"StatusGUID", szStatusGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = pActionEventSink->Indicate(1, &pActionInstance); //WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver. if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY) { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"Failed on Indicate!", 4); } } if (pActionTriggerEventSink) { hRetRes = pActionTriggerEventSink->Indicate(1, &pActionTriggerInstance); //WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver. if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY) { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"Failed on Indicate!", 4); } } pInstance->Release(); pInstance = NULL; } else { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"failed to get instance!", 4); } } } if (firstInstanceState==-1) { state = PassBackWorstStatePerInstance(L"CollectionErrorCode", FALSE); if (state==-1) state = HM_COLLECTING; // Check to see if still in the desired state if ((ulTriggerStates&(1<AddRef(); hRetRes = (pActionTriggerInstance)->Put(bsName, 0L, &v, 0L); VariantClear(&v); SysFreeString(bsName); bsName = NULL; MY_HRESASSERT(hRetRes); if (pActionEventSink) { hRetRes = CoCreateGuid(&guid); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; StringFromGUID2(guid, szStatusGUID, 100); hRetRes = PutStrProperty(pActionInstance, L"StatusGUID", szStatusGUID); MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error; hRetRes = pActionEventSink->Indicate(1, &pActionInstance); //WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver. if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY) { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"Failed on Indicate!", 4); } } if (pActionTriggerEventSink) { hRetRes = pActionTriggerEventSink->Indicate(1, &pActionTriggerInstance); //WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver. if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY) { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"Failed on Indicate!", 4); } } pInstance->Release(); pInstance = NULL; } else { MY_HRESASSERT(hRetRes); MY_OUTPUT(L"failed to get instance!", 4); } } } #ifdef SAVE state = PassBackWorstStatePerInstance(L"CollectionErrorDescription"); #endif MY_OUTPUT(L"EXIT ***** CDataCollector::SendReminderActionIfStateIsSame...", 2); return TRUE; error: MY_ASSERT(FALSE); if (bsName) SysFreeString(bsName); if (pInstance) pInstance->Release(); m_bValidLoad = FALSE; Cleanup(FALSE); return FALSE; } HRESULT CDataCollector::insertNewProperty(LPTSTR pszPropertyName) { HRESULT hRetRes = S_OK; int i, iSize; PNSTRUCT *ppn; BOOL bFound = FALSE; BOOL bDoInsert = FALSE; PNSTRUCT pn; PNLIST::iterator iaPN; bFound = FALSE; iaPN=m_pnList.begin(); iSize = m_pnList.size(); for (i=0; iszPropertyName, pszPropertyName)) { bFound = TRUE; ppn->iRefCount++; break; } // We know it can't be further than this one, and we can insert here if (!_wcsicmp(ppn->szPropertyName, L"CollectionInstanceCount")) { bDoInsert = TRUE; break; } } // Add it it is new! if (bFound == FALSE) { pn.szPropertyName = new TCHAR[wcslen(pszPropertyName)+2]; MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;} wcscpy(pn.szPropertyName, pszPropertyName); pn.iRefCount = 1; pn.type = 0; if (bDoInsert) { m_pnList.insert(iaPN, pn); } else { m_pnList.push_back(pn); } } return hRetRes; error: MY_ASSERT(FALSE); m_bValidLoad = FALSE; Cleanup(FALSE); return hRetRes; } BOOL CDataCollector::propertyNotNeeded(LPTSTR pszPropertyName) { int j, jSize; int k, kSize; PNSTRUCT *ppn; BOOL bAdded = FALSE; PNLIST::iterator iaPN; INSTSTRUCT *pinst; // // Delete the property if this Threshold was the last one that needed it. // Refcount if there already. // iaPN=m_pnList.begin(); jSize = m_pnList.size(); for (j=0; jszPropertyName, pszPropertyName)) { ppn->iRefCount--; if (ppn->iRefCount==0) { kSize = ppn->instList.size(); for (k = 0; k < kSize ; k++) { MY_ASSERT(kinstList.size()); pinst = &ppn->instList[k]; if (pinst->szCurrValue) { delete [] pinst->szCurrValue; } if (pinst->szInstanceID) { delete [] pinst->szInstanceID; } pinst->valList.clear(); } ppn->instList.clear(); m_pnList.erase(iaPN); } break; } // We know it can't be further than this one, and we can insert here if (!_wcsicmp(ppn->szPropertyName, L"CollectionInstanceCount")) { break; } } return TRUE; } BOOL CDataCollector::ResetInst(INSTSTRUCT *pinst, CIMTYPE type) { if (type == CIM_REAL32) { pinst->currValue.fValue = 0; pinst->minValue.fValue = MAX_FLOAT; pinst->maxValue.fValue = 0; pinst->avgValue.fValue = 0; } else if (type == CIM_REAL64) { pinst->currValue.dValue = 0; pinst->minValue.dValue = MAX_DOUBLE; pinst->maxValue.dValue = 0; pinst->avgValue.dValue = 0; } else if (type == CIM_SINT64) { pinst->currValue.i64Value = 0; pinst->minValue.i64Value = MAX_I64; pinst->maxValue.i64Value = 0; pinst->avgValue.i64Value = 0; } else if (type == CIM_UINT64) { pinst->currValue.ui64Value = 0; pinst->minValue.ui64Value = MAX_UI64; pinst->maxValue.ui64Value = 0; pinst->avgValue.ui64Value = 0; } else if (type == CIM_UINT32) { pinst->currValue.ulValue = 0; pinst->minValue.ulValue = MAX_ULONG; pinst->maxValue.ulValue = 0; pinst->avgValue.ulValue = 0; } else { pinst->currValue.lValue = 0; pinst->minValue.lValue = MAX_LONG; pinst->maxValue.lValue = 0; pinst->avgValue.lValue = 0; } return TRUE; } BOOL CDataCollector::CheckForReset(void) { BOOL bFoundReset; BOOL bFoundNonNormal; // PNSTRUCT *ppn; long state; int i, iSize; // int j, jSize; CThreshold* pThreshold; // INSTSTRUCT *pinst; // ACTUALINSTSTRUCT *pActualInst; // // See if we have a Threshold in the RESET state // bFoundReset = FALSE; bFoundNonNormal = FALSE; iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iGetCurrState(); if (state == HM_RESET) { bFoundReset = TRUE; } if (state==HM_WARNING || state==HM_CRITICAL) { bFoundNonNormal = TRUE; } if (bFoundReset && bFoundNonNormal) break; } if (bFoundReset && bFoundNonNormal) { // If we don't call the base method, we may get into an endless loop. CDataCollector::EvaluateThresholds(TRUE, TRUE, FALSE, FALSE); CDataCollector::EvaluateThresholds(TRUE, FALSE, TRUE, FALSE); // // Set back the RESET one(s) // m_lCurrState = HM_COLLECTING; iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iGetCurrState() == HM_RESET) { pThreshold->SetCurrState(HM_GOOD); } } } //#ifdef SAVE //XXX???Do we want the following??? else if (bFoundReset) { if (m_deType!=HM_EQDE && m_bRequireReset) { iSize = m_thresholdList.size(); for (i = 0; i < iSize ; i++) { MY_ASSERT(iGetCurrState() == HM_RESET) { pThreshold->ResetResetThreshold(); } } } } //#endif return TRUE; } HRESULT CDataCollector::CheckForBadLoad(void) { HRESULT hRetRes = S_OK; IWbemClassObject* pObj = NULL; TCHAR szTemp[1024]; IWbemClassObject* pInstance = NULL; if (m_bValidLoad == FALSE) { wcscpy(szTemp, L"MicrosoftHM_DataCollectorConfiguration.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 (GetHMDataCollectorStatusInstance(&pInstance, TRUE) == S_OK) { mg_DCEventList.push_back(pInstance); } } else { if (GetHMDataCollectorStatusInstance(&pInstance, TRUE) == S_OK) { mg_DCEventList.push_back(pInstance); } ResetState(TRUE, TRUE); } MY_HRESASSERT(hRetRes); pObj->Release(); pObj = NULL; return hRetRes; } return S_OK; }