// (Usually internal) method to perform usb drive search bool DeviceFinder::MappingUsbstorToDeviceNumber(std::map<std::string, int>& usbStorToDeviceMap) { HRESULT hr; // Clear list of drive names usbStorToDeviceMap.clear(); // Ensure pSvc is initialized if (!Initialize()) { Log(0, "ERROR: Unable to initialize for usbstor-deviceNumber mapping.\n"); return false; } // Use the IWbemServices pointer to make a WMI request for Win32_SerialPort IEnumWbemClassObject* pEnumerator = NULL; IWbemServices *pServices = (IWbemServices *)pSvc; // Cast required as the public API doesn't include the type information if (pServices == NULL) { Log(0, "ERROR: Unable to get usbstor-deviceNumber mapping.\n"); return false; } hr = pServices->ExecQuery(bstr_t("WQL"), bstr_t("SELECT PNPDeviceID, DeviceID FROM Win32_DiskDrive WHERE InterfaceType='USB'"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hr)) { Log(0, "ERROR: Query for Win32_DiskDrive has failed: 0x%08x\n", hr); return false; } // Get the data from the query if (pEnumerator) { for (;;) { // Get next item in enumeration IWbemClassObject *pclsObj; ULONG uReturn = 0; hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); // If no more items, exit loop if (uReturn == 0) { break; } // Get value of the "PNPDeviceID" property VARIANT vtProp; hr = pclsObj->Get(L"PNPDeviceID", 0, &vtProp, 0, 0); char usbstorId[256] = { 0 }; wcstombs_s(NULL, usbstorId, vtProp.bstrVal, 255); // Convert to ASCII VariantClear(&vtProp); //cerr << "[DRIVE:USBSTOR] " << usbstorId << endl; // Get value of the "DeviceID" property hr = pclsObj->Get(L"DeviceID", 0, &vtProp, 0, 0); char deviceId[256] = { 0 }; wcstombs_s(NULL, deviceId, vtProp.bstrVal, 255); // Convert to ASCII unsigned int deviceNumber = GetDeviceNumber(vtProp.bstrVal); VariantClear(&vtProp); //cerr << "[DRIVE:DEVICEID] " << deviceId << endl; //cerr << "[DRIVE:DEVICENUMBER] " << deviceNumber << endl; //DiskDriveToLogicalDrive(deviceId); #ifdef DEBUG_PRINT Log(3, "[USBSTOR->DEVICEID->DEVICENUMBER] %s -> %s -> %u\n", usbstorId, deviceId, deviceNumber); #endif usbStorToDeviceMap[usbstorId] = deviceNumber; pclsObj->Release(); } pEnumerator->Release(); } return true; }
HRESULT wmi_get_proc_string_property(sigar_t *sigar, DWORD pid, TCHAR * name, TCHAR * value, DWORD len) { IWbemClassObject *obj; VARIANT var; HRESULT result; if(sigar->wmi_handle == NULL) return (E_INVALIDARG); wchar_t query[56]; wsprintf(query, L"Win32_Process.Handle=%d", pid); result = sigar->wmi_handle->services->GetObject(query, 0, 0, &obj, 0); if (FAILED(result)) { return result; } result = obj->Get(name, 0, &var, 0, 0); if (SUCCEEDED(result)) { if (var.vt == VT_NULL) { result = E_INVALIDARG; } else { lstrcpyn(value, var.bstrVal, len); } VariantClear(&var); } obj->Release(); return result; }
static bool TryAddress(const std::string& ipAddress) { IEnumWbemClassObject* enumerator = 0; std::wstring query(L"SELECT * FROM Win32_PingStatus WHERE (Address=\""); query.append(::UTF8ToWide(ipAddress)); query.append(L"\")"); BSTR queryBstr = SysAllocString(query.c_str()); HRESULT result = service->ExecQuery(L"WQL", queryBstr, WBEM_FLAG_FORWARD_ONLY, 0, &enumerator); SysFreeString(queryBstr); if (FAILED(result)) { HandleHResultError("Failed to execute address query", result); return false; } ULONG count; IWbemClassObject* ping = 0; result = enumerator->Next(WBEM_INFINITE, 1L, &ping, &count); if (FAILED(result)) { HandleHResultError("Failed to get ping data", result); enumerator->Release(); return false; } if (count < 1) { LogError("Did not find ping result"); enumerator->Release(); ping->Release(); return false; } variant_t pingValue; result = ping->Get(L"StatusCode", 0, &pingValue, 0, 0); if (FAILED(result)) { HandleHResultError("Could not get ping StatusCode value", result); enumerator->Release(); ping->Release(); return false; } ping->Release(); return static_cast<int>(pingValue) == 0; }
void IPodDetector::checkConnectedDevices() { IEnumWbemClassObject* currentDevicesEnumerator = NULL; queryCurrentlyConnectedDevices( ¤tDevicesEnumerator ); IWbemClassObject* device; ULONG returnCount = 0; while( currentDevicesEnumerator ) { currentDevicesEnumerator->Next( WBEM_INFINITE, 1, &device, &returnCount ); if( 0 == returnCount ) { break; } if( returnCount > 0 ) { LOGL( 3, "Detected pre-connected iPod" ); onDeviceConnected( device ); } device->Release(); } currentDevicesEnumerator->Release(); }
SCODE CreateInst(IWbemServices * pNamespace, LPWSTR pKey, long lVal, IWbemClassObject ** pNewInst, WCHAR * pwcClassName, IWbemContext *pCtx) { SCODE sc; IWbemClassObject * pClass = NULL; sc = pNamespace->GetObject(pwcClassName, 0, pCtx, &pClass, NULL); if(sc != S_OK) return WBEM_E_FAILED; sc = pClass->SpawnInstance(0, pNewInst); pClass->Release(); if(FAILED(sc)) return sc; VARIANT v; // Set the key property value. v.vt = VT_BSTR; v.bstrVal = SysAllocString(pKey); if (!v.bstrVal) return WBEM_E_OUT_OF_MEMORY; sc = (*pNewInst)->Put(L"MyKey", 0, &v, 0); VariantClear(&v); if(FAILED(sc)) return sc; // Set the number property value. v.vt = VT_I4; v.lVal = lVal; sc = (*pNewInst)->Put(L"MyValue", 0, &v, 0); return sc; }
static int get_username() { IEnumWbemClassObject *enumerator = 0; IWbemClassObject * object = 0; bool res = false; _username = bstr_t(); enumerator = request(bstr_t("select UserName from Win32_ComputerSystem")); VARIANT vUsername; VariantInit(&vUsername); ULONG uReturn; for(;;) { HRESULT result = enumerator->Next(WBEM_INFINITE, 1, &object, &uReturn); if(uReturn == 0) { break; } result = object->Get(L"UserName", 0, &vUsername, 0, 0); if (SUCCEEDED(result)) { _username = GetShortName(vUsername.bstrVal); res = true; } object->Release(); } if (enumerator) enumerator->Release(); //std::cout << "get_username(): " << _username << std::endl; return res; }
HRESULT WMI::GetProcStringProperty(DWORD pid, TCHAR *name, TCHAR *value, DWORD len) { IWbemClassObject *obj; VARIANT var; result = wbem->GetObject(GetProcQuery(pid), 0, 0, &obj, 0); if (FAILED(result)) { return result; } result = obj->Get(name, 0, &var, 0, 0); if (SUCCEEDED(result)) { if (var.vt == VT_NULL) { result = E_INVALIDARG; } else { lstrcpyn(value, var.bstrVal, len); } VariantClear(&var); } obj->Release(); return result; }
/** * Finds the associated Win32_NetworkAdapterConfiguration for Win32_NetworkAdapter adapterObj. * Iterates through the IP addresses associated with the adapter calling * stringToAdaptorIp() to choose the highest priority address (according to EnumIPSelectionPriority) * as the adapter address which is used to populate adapter->userData->ipAddr. * If two addresses have the same highest priority, then the first one seen is chosen. */ static void readIpAddressesWin32(IWbemServices *pNamespace, IWbemClassObject *adapterObj, SFLAdaptor *adaptor) { IEnumWbemClassObject *configEnum; HRESULT hr = associatorsOf(pNamespace, adapterObj, L"Win32_NetworkAdapterSetting", L"Win32_NetworkAdapterConfiguration", L"Setting", &configEnum); if (SUCCEEDED(hr)) { IWbemClassObject *configObj; ULONG configCount; hr = configEnum->Next(WBEM_INFINITE, 1, &configObj, &configCount); if (SUCCEEDED(hr) && configCount == 1) { VARIANT addresses; hr = configObj->Get(L"IPAddress", 0, &addresses, 0, 0); if (WBEM_S_NO_ERROR == hr && addresses.vt == (VT_ARRAY | VT_BSTR)) { SAFEARRAY *sa = V_ARRAY(&addresses); LONG lstart, lend; hr = SafeArrayGetLBound(sa, 1, &lstart); hr = SafeArrayGetUBound(sa, 1, &lend); BSTR *pbstr; hr = SafeArrayAccessData(sa, (void HUGEP **)&pbstr); if (SUCCEEDED(hr)) { for (LONG idx=lstart; idx <= lend; idx++) { PCWSTR addrStr = pbstr[idx]; stringToAdaptorIp(addrStr, adaptor); } SafeArrayUnaccessData(sa); } } VariantClear(&addresses); configObj->Release(); } configEnum->Release(); } }
/* * Solution by: Simon Mourier * From: http://stackoverflow.com/questions/5327203/how-to-access-cpus-heat-sensors * * For linking use: Wbemuuid.lib * Running info: application must run under administrator privileges! */ double SystemInfo::DiagnosticMgr::getCpuTemp() { LONG result; LPLONG pTemperature = &result; *pTemperature = -1; HRESULT ci = CoInitialize(NULL); // needs comdef.h HRESULT hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL); if (SUCCEEDED(hr)) { IWbemLocator *pLocator; // needs Wbemidl.h & Wbemuuid.lib hr = CoCreateInstance(CLSID_WbemAdministrativeLocator, NULL, CLSCTX_INPROC_SERVER , IID_IWbemLocator, (LPVOID*)&pLocator); if (SUCCEEDED(hr)) { IWbemServices *pServices; BSTR ns = SysAllocString(L"root\\WMI"); hr = pLocator->ConnectServer(ns, NULL, NULL, NULL, 0, NULL, NULL, &pServices); pLocator->Release(); SysFreeString(ns); if (SUCCEEDED(hr)) { BSTR query = SysAllocString(L"SELECT * FROM MSAcpi_ThermalZoneTemperature"); BSTR wql = SysAllocString(L"WQL"); IEnumWbemClassObject *pEnum; hr = pServices->ExecQuery(wql, query, WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pEnum); SysFreeString(wql); SysFreeString(query); pServices->Release(); if (SUCCEEDED(hr)) { IWbemClassObject *pObject; ULONG returned; hr = pEnum->Next(-1, 1, &pObject, &returned); pEnum->Release(); if (SUCCEEDED(hr)) { BSTR temp = SysAllocString(L"CurrentTemperature"); VARIANT v; VariantInit(&v); hr = pObject->Get(temp, 0, &v, NULL, NULL); pObject->Release(); SysFreeString(temp); if (SUCCEEDED(hr)) { *pTemperature = V_I4(&v); } VariantClear(&v); } } } if (ci == S_OK) { CoUninitialize(); } } } double tempInTensOfKelvins = (double)*pTemperature; return (tempInTensOfKelvins > 0.0) ? ((double)*pTemperature / 10.0) - 273.15 : 0.0; }
/** * Enumerates MSFT_NetIpAddress whose interface index is the same as the * adaptor's. Calls stringToAdaptorIP() for each object so that the * highest priority IP address is associated with the adaptor. */ static void readIpAddressesMsft(IWbemServices *pNamespace, SFLAdaptor *adaptor) { BSTR queryLang = SysAllocString(L"WQL"); wchar_t *query = L"SELECT * FROM MSFT_NetIpAddress WHERE InterfaceIndex=%u"; wchar_t ipQuery[70]; swprintf_s(ipQuery, 70, query, adaptor->ifIndex); IEnumWbemClassObject *ipEnum = NULL; HRESULT hr = pNamespace->ExecQuery(queryLang, ipQuery, WBEM_FLAG_FORWARD_ONLY, NULL, &ipEnum); SysFreeString(queryLang); if (!SUCCEEDED(hr)) { myLog(LOG_ERR,"readIpAddressesMsft: ExecQuery() failed for query %S error=0x%x", ipQuery, hr); return; } IWbemClassObject *ipObj; hr = WBEM_S_NO_ERROR; while (WBEM_S_NO_ERROR == hr) { ULONG ipCount = 0; hr = ipEnum->Next(WBEM_INFINITE, 1, &ipObj, &ipCount); if (ipCount == 0) { break; } VARIANT address; hr = ipObj->Get(L"IPAddress", 0, &address, 0, 0); if (WBEM_S_NO_ERROR == hr && V_VT(&address) == VT_BSTR) { stringToAdaptorIp(address.bstrVal, adaptor); } VariantClear(&address); ipObj->Release(); } ipEnum->Release(); }
int wmi_get_cpu_frequency(float* pcpu_frequency) { assert(_initialized); assert(pcpu_frequency); float& cpu_frequency = *pcpu_frequency; IEnumWbemClassObject *enumerator = 0; IWbemClassObject * object = 0; // Use the IWbemServices pointer to make requests of WMI ---- static const bstr_t WQL = bstr_t("WQL"); static const bstr_t Query = bstr_t("SELECT CurrentClockSpeed FROM Win32_Processor"); HRESULT result = services->ExecQuery(WQL, Query, WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &enumerator ); if (FAILED(result)) { log_err("Query for operating system name failed." " Error code = %d \n", result); services->Release(); locator->Release(); CoUninitialize(); //TODO return valid error return -1; } VARIANT variant; ULONG uReturn; for(;;) { result = enumerator->Next(WBEM_INFINITE, 1, &object, &uReturn); if(0 == uReturn) { break; } VariantInit(&variant); result = object->Get(L"CurrentClockSpeed", 0, &variant, 0, 0); if (result == WBEM_S_NO_ERROR) { //Variant::Print(variant); cpu_frequency = (float)variant.iVal; } object->Release(); } if (enumerator) enumerator->Release(); return 0; }
static int get_num_core() { IEnumWbemClassObject *enumerator = 0; IWbemClassObject * object = 0; int res = -1; _num_core = 0; enumerator = request(bstr_t("select NumberOfCores from Win32_Processor")); VARIANT vUsername; VariantInit(&vUsername); ULONG uReturn; for(;;) { HRESULT result = enumerator->Next(WBEM_INFINITE, 1, &object, &uReturn); if(uReturn == 0) { break; } result = object->Get(L"NumberOfCores", 0, &vUsername, 0, 0); if (SUCCEEDED(result)) { _num_core = vUsername.uiVal; res = 0; } object->Release(); } if (enumerator) enumerator->Release(); //std::cout << "get_num_core(): " << _num_core << std::endl; return res; }
VARIANT* GpuCapabilitiesWindows::WMIquery(std::string wmiClass, std::string attribute) { // Code based upon: "Example: Getting WMI Data from the Local Computer" // http://msdn2.microsoft.com/en-us/library/aa390423.aspx if (!isWMIinited()) { LWARNING("WMI not initiated"); return 0; } HRESULT hres; VARIANT* result = 0; // Step 6: -------------------------------------------------- // Use the IWbemServices pointer to make requests of WMI ---- IEnumWbemClassObject* pEnumerator = NULL; std::string query = "SELECT " + attribute + " FROM " + wmiClass; hres = pWbemServices_->ExecQuery( bstr_t("WQL"), bstr_t(query.c_str()), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hres)) { LWARNING("ERROR: WMI query failed: " << query); return 0; } // Step 7: ------------------------------------------------- // Get the data from the query in step 6 ------------------- IWbemClassObject* pclsObj = 0; ULONG uReturn = 0; if (pEnumerator) { HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (uReturn) { // Get the value of the attribute and store it in result result = new VARIANT; hr = pclsObj->Get(LPCWSTR(str2wstr(attribute).c_str()), 0, result, 0, 0); } } if (!result) { LWARNING("No WMI query result"); } // Clean enumerator and pclsObject if (pEnumerator) pEnumerator->Release(); if (pclsObj) pclsObj->Release(); return result; }
HRESULT CRefClient::AddObjects() /////////////////////////////////////////////////////////////////// // // AddObject will add a set of objects to the refresher. The // method will update m_aInstances with the instance data. // // Returns a status code. Use the SUCCEEDED() and FAILED() macros // to interpret results. // /////////////////////////////////////////////////////////////////// //ok { HRESULT hRes = WBEM_NO_ERROR; long lIndex = 0; WCHAR wcsObjName[MAX_PATH + 50]; // Loop through all instances of Win32_BasicHiPerf and add them to the refresher // ============================================================================= for ( lIndex = 0; lIndex < clNumInstances; lIndex++ ) { IWbemClassObject* pObj = NULL; IWbemObjectAccess* pAccess = NULL; long lID; // Set the object path (e.g. Win32_BasicHiPerf=1) // ============================================== StringCbPrintfW(wcsObjName, sizeof(wcsObjName), L"%s=%i", cwcsObjectPath, lIndex ); // Add the object // ============== hRes = m_pConfig->AddObjectByPath( m_pNameSpace, wcsObjName, 0, NULL, &pObj, &lID ); if ( FAILED( hRes ) ) { printf( "AddObjectByPath() failed, 0x%x\n", hRes ); return hRes; } // Save the IWbemObjectAccess interface // ==================================== hRes = pObj->QueryInterface( IID_IWbemObjectAccess, (void**) &pAccess ); pObj->Release(); m_Instances[lIndex].Set(pAccess, lID); // Set does it's own AddRef() // ========================== pAccess->Release(); } return hRes; }
HRESULT EventSink::Indicate(long lObjectCount, IWbemClassObject **apObjArray) { HRESULT hres = S_OK; try { for (int i = 0; i < lObjectCount; i++) { VARIANT vVar; _variant_t vTarget; // pkg status object IUnknown *pIUnknown; IWbemClassObject *pinstPkgStatus = NULL; _variant_t vName; // _variant_t vExecutablePath; // _variant_t vCommandLine; // hres = (apObjArray[0])->Get(L"TargetInstance", 0, &vTarget, NULL, NULL); if (FAILED(hres)) { cout << "Failed to get TargetInstance in apObjArray[i]: " << hres << endl; }//if pIUnknown = (IUnknown *)vTarget; hres = pIUnknown->QueryInterface(IID_IWbemClassObject, (void **)&pinstPkgStatus); if (FAILED(hres)) { cout << "Failed to get IID_IWbemClassObject in TargetInstance: " << hres << endl; }//if pIUnknown->Release(); //================================================================================== hres = pinstPkgStatus->Get(L"Name", 0, &vName, NULL, NULL); Print(hres, vName, L"Name"); hres = pinstPkgStatus->Get(L"ExecutablePath", 0, &vExecutablePath, NULL, NULL); Print(hres, vExecutablePath, L"ExecutablePath"); hres = pinstPkgStatus->Get(L"CommandLine", 0, &vCommandLine, NULL, NULL); Print(hres, vCommandLine, L"CommandLine"); pinstPkgStatus->Release(); pinstPkgStatus = NULL; cout << endl << endl; }//for }//try catch(_com_error &err) { cout << "caught _com_error: " << err.Error() << endl; cout << "caught Description: " << err.Description() << endl; cout << "caught ErrorMessage: " << err.ErrorMessage() << endl; }//catch return WBEM_S_NO_ERROR; }//Indicate
std::list<VideoMonitor::DisplayControllerConfigurationData*> VideoMonitor::CDisplayControllerConfiguration::GetData(){ IWbemClassObject *pclsObj = NULL; ULONG uReturn = 0; std::list<VideoMonitor::DisplayControllerConfigurationData*> displayControllerConfiguration; VideoMonitor::DisplayControllerConfigurationData* displayControllerConfigurationData; if(!this->MakeWMIRequest(L"SELECT * FROM Win32_DisplayControllerConfiguration")) return displayControllerConfiguration; while(this->PEnumerator){ this->PEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if(0 == uReturn) break; displayControllerConfigurationData = new VideoMonitor::DisplayControllerConfigurationData; displayControllerConfigurationData->BitsPerPixel = this->GetUIntValue(pclsObj, L"BitsPerPixel"); displayControllerConfigurationData->Caption = this->GetStringValue(pclsObj, L"Caption"); displayControllerConfigurationData->ColorPlanes = this->GetUIntValue(pclsObj, L"ColorPlanes"); displayControllerConfigurationData->Description = this->GetStringValue(pclsObj, L"Description"); displayControllerConfigurationData->DeviceEntriesInAColorTable = this->GetUIntValue(pclsObj, L"DeviceEntriesInAColorTable"); displayControllerConfigurationData->DeviceSpecificPens = this->GetUIntValue(pclsObj, L"DeviceSpecificPens"); displayControllerConfigurationData->HorizontalResolution = this->GetUIntValue(pclsObj, L"HorizontalResolution"); displayControllerConfigurationData->Name = this->GetStringValue(pclsObj, L"Name"); displayControllerConfigurationData->RefreshRate = this->GetUIntValue(pclsObj, L"RefreshRate"); displayControllerConfigurationData->ReservedSystemPaletteEntries = this->GetUIntValue(pclsObj, L"ReservedSystemPaletteEntries"); displayControllerConfigurationData->SettingID = this->GetStringValue(pclsObj, L"SettingID"); displayControllerConfigurationData->SystemPaletteEntries = this->GetUIntValue(pclsObj, L"SystemPaletteEntries"); displayControllerConfigurationData->VerticalResolution = this->GetUIntValue(pclsObj, L"VerticalResolution"); displayControllerConfigurationData->VideoMode = this->GetStringValue(pclsObj, L"VideoMode"); displayControllerConfiguration.push_back(displayControllerConfigurationData); pclsObj->Release(); } return displayControllerConfiguration; }
/* Return the CPU usage in percent of this process */ int getcpu() { HRESULT hres; int cpu = -1; /* Use WQL, similar to SQL, to construct a query that lists the cpu usage and pid of all processes */ IEnumWbemClassObject* pEnumerator = NULL; BSTR Language = SysAllocString(L"WQL"); BSTR Query = SysAllocString(L"Select PercentProcessorTime,IDProcess from Win32_PerfFormattedData_PerfProc_Process"); hres = pSvc->ExecQuery(Language, Query, WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); /* Query didn't work */ if (!FAILED(hres)) { IWbemClassObject *pclsObj = NULL; ULONG uReturn = 0; /* Iterate the query results */ while (pEnumerator) { VARIANT vtProp; VariantInit(&vtProp); /* Next item */ HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); /* No more items left */ if (uReturn == 0) break; /* Find process ID */ hr = pclsObj->Get(L"IDProcess", 0, &vtProp, 0, 0); if (!FAILED(hr)) { /* Matches our process ID? */ UINT pid = vtProp.uintVal; VariantClear(&vtProp); if (pid == GetCurrentProcessId()) { /* Get CPU percentage for this process */ hr = pclsObj->Get(L"PercentProcessorTime", 0, &vtProp, 0, 0); if (!FAILED(hr)) { /* Deal with wide string ickyness. Who in their right * mind puts a number in a bstrVal wide string item?! */ cpu = 0; std::wstringstream out(vtProp.bstrVal); out >> cpu; VariantClear(&vtProp); } pclsObj->Release(); break; }
std::shared_ptr<CHardware> CHardwareFactory::newOpticalDiscDrive() const { /* * IWbemServices::ExecQuery http://msdn.microsoft.com/en-us/library/windows/desktop/aa392107%28v=VS.85%29.aspx * IWbemClassObject::Next http://msdn.microsoft.com/en-us/library/windows/desktop/aa391453%28v=VS.85%29.aspx * IWbemClassObject::Get http://msdn.microsoft.com/en-us/library/windows/desktop/aa391442%28v=VS.85%29.aspx * Win32_CDROMDrive class http://msdn.microsoft.com/en-us/library/windows/desktop/aa394081%28v=VS.85%29.aspx * * Creating a WMI Application Using C++ http://msdn.microsoft.com/en-us/library/windows/desktop/aa389762%28v=VS.85%29.aspx */ IEnumWbemClassObject* enumerator = 0; HRESULT hr = mWbemServices->ExecQuery(BSTR(L"WQL"), BSTR(L"SELECT * FROM Win32_CDROMDrive"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, 0, &enumerator); if (FAILED(hr)) { throw CBasicException("ExecQuery failed"); } std::list<std::string> opticalDriveList; while(enumerator) { IWbemClassObject* obj = 0; ULONG ret = 0; hr = enumerator->Next(WBEM_INFINITE, 1, &obj, &ret); if (ret == 0 || FAILED(hr)) { break; } VARIANT vtProp; hr = obj->Get(L"Caption", 0, &vtProp, 0, 0); if (FAILED(hr)) { continue; } opticalDriveList.push_back(CUtils::str2utf8(vtProp.bstrVal)); VariantClear(&vtProp); obj->Release(); } enumerator->Release(); return std::shared_ptr<CHardware>(new CHardware(CHardware::OPTICALDISCDRIVE, opticalDriveList)); }
static SCODE _makeGadget( IWbemServices* nameSpace, LPWSTR key, long value, IWbemClassObject** newInstance, WCHAR* className, IWbemContext* context) { SCODE sc; VARIANT v; // Allocate a new instance: IWbemClassObject* classObject = NULL; sc = nameSpace->GetObject(className, 0, context, &classObject, NULL); if (sc != S_OK) return WBEM_E_FAILED; sc = classObject->SpawnInstance(0, newInstance); classObject->Release(); if (FAILED(sc)) return sc; // Set the key property value. v.vt = VT_BSTR; v.bstrVal = SysAllocString(key); if (!v.bstrVal) return WBEM_E_OUT_OF_MEMORY; sc = (*newInstance)->Put(L"MyKey", 0, &v, 0); VariantClear(&v); if (FAILED(sc)) return sc; // Set the number property value. v.vt = VT_I4; v.lVal = value; sc = (*newInstance)->Put(L"MyValue", 0, &v, 0); if (FAILED(sc)) return sc; return S_OK; }
/* Check VMWare bios using WMI */ BOOL vmware_wmi() { IWbemServices *pSvc = NULL; IWbemLocator *pLoc = NULL; IEnumWbemClassObject* pEnumerator = NULL; BOOL bStatus = FALSE; HRESULT hr; // Init WMI bStatus = InitWMI(&pSvc, &pLoc); if (bStatus) { // If success, execute the desired query bStatus = ExecWMIQuery(&pSvc, &pLoc, &pEnumerator, _T("SELECT * FROM Win32_PnPEntity")); if (bStatus) { // Get the data from the query IWbemClassObject *pclsObj = NULL; ULONG uReturn = 0; VARIANT vtProp; while (pEnumerator) { hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (0 == uReturn) break; // Get the value of the Name property hr = pclsObj->Get(_T("DeviceId"), 0, &vtProp, 0, 0); //_tprintf(_T("DeviceId : %s"), vtProp.bstrVal); // release the current result object VariantClear(&vtProp); pclsObj->Release(); } } } // Cleanup pSvc->Release(); pLoc->Release(); pEnumerator->Release(); CoUninitialize(); return TRUE; }
/** * Test to see whether we are running on a system with Hyper-V enabled. * We consider Hyper-V to be running (and can export per vm stats) if * the Hyper-V related services (nvspwmi, vmm, vhdsvc) are running and * we can access the WMI namespace root\virtualization (ie v1 for Win 2008). * We do not check for the v2 namespace, since this is not required for * per vm stats. * The ability connect to the sFlow filter for export of packet samples * and counter samples for the virtual switch is made separately. */ BOOL testForHyperv() { BSTR path = SysAllocString(WMI_CIMV2_NS); HRESULT hr = S_FALSE; IWbemServices *pNamespace = NULL; hr = connectToWMI(path, &pNamespace); SysFreeString(path); if (WBEM_S_NO_ERROR != hr) { myLog(LOG_ERR,"testForHyperv: connectToWMI failed for namespace %S", path); return false; } //Test for Hyper-V services BOOL gotHyperV = false; BSTR queryLang = SysAllocString(L"WQL"); BSTR query = SysAllocString(L"SELECT * FROM Win32_Service WHERE Name=\"nvspwmi\" OR Name=\"vmms\" OR Name=\"vhdsvc\""); IEnumWbemClassObject *serviceEnum = NULL; hr = pNamespace->ExecQuery(queryLang, query, WBEM_FLAG_FORWARD_ONLY, NULL, &serviceEnum); SysFreeString(query); SysFreeString(queryLang); if (WBEM_S_NO_ERROR != hr) { myLog(LOG_ERR, "testForHyperv: ExecQuery() failed for %S error=0x%x", query, hr); } else { IWbemClassObject *serviceObj = NULL; ULONG uReturned = 0; BOOL gotHyperVSvc = false; hr = serviceEnum->Next(WBEM_INFINITE, 1, &serviceObj, &uReturned); if (SUCCEEDED(hr)) { if (uReturned == 1) { gotHyperVSvc = true; serviceObj->Release(); } } serviceEnum->Release(); pNamespace->Release(); if (gotHyperVSvc) { //now check that we have the v1 virtualization namespace CoUninitialize(); path = SysAllocString(WMI_VIRTUALIZATION_NS_V1); hr = connectToWMI(path, &pNamespace); SysFreeString(path); if (WBEM_NO_ERROR == hr) { gotHyperV = true; pNamespace->Release(); } } } CoUninitialize(); myLog(LOG_INFO, "testForHyperv: HyperV=%u", gotHyperV); return gotHyperV; }
int getTimeProcessors(IWbemServices *pSvc,ULONG *ulVal ,int n) { int nError = 0; IEnumWbemClassObject* pEnumerator = NULL; HRESULT hres = pSvc->ExecQuery( L"WQL", L"SELECT * FROM Win32_PerfRawData_PerfOS_Processor", WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (FAILED(hres)) { ShowMessage("Query for operating system name failed."); return 1; } IWbemClassObject *pclsObj; ULONG uReturn = 0; int nCtr = 0; while (nCtr<n) { pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if(0 == uReturn) { break; } VARIANT vtProp; VariantInit(&vtProp); pclsObj->Get(L"PercentProcessorTime", 0, &vtProp, 0, 0); ulVal[nCtr] = _wtol(vtProp.bstrVal); VariantClear(&vtProp); pclsObj->Get(L"TimeStamp_Sys100NS", 0, &vtProp, 0, 0);// время в милисекундах прошедших с получночи 1 января 1970 года ulVal[nCtr+1] = _wtol(vtProp.bstrVal); VariantClear(&vtProp); nCtr+=2; } pclsObj->Release(); pEnumerator->Release(); return nError; }
void ListClasses(IWbemServices *pNamespace) { HRESULT hr; IEnumWbemClassObject *pEnum = NULL; hr = pNamespace->CreateClassEnum(NULL, 0, NULL, &pEnum); if(SUCCEEDED(hr)) { // Note that even though security was set on the namespace pointer, it must // also be set on this pointer since COM will revert back to the default // settings for any new pointers! hr = SetProxySecurity(pEnum); if(SUCCEEDED(hr)) { IWbemClassObject* Array[1]; Array[0] = NULL; ULONG uRet = 0; while (SUCCEEDED(hr = pEnum->Next(10000, 1, Array, &uRet)) && Array[0]) { // Note that IWbemClassObjects are inproc and thus have no proxy. // Therefore, they never need CoSetProxyBlanket. BSTR strText; IWbemClassObject* pObj = Array[0]; hr = pObj->GetObjectText(0, &strText); if(SUCCEEDED(hr) && strText) { printf("\nGot class %S", strText); SysFreeString(strText); } pObj->Release(); Array[0] = NULL; } } else printf("\nFAILED TO SET SECURITY FOR ENUMERATOR!!!!! hr = 0x%x", hr); pEnum->Release(); } }
BOOL _GetClassObjectValue(IEnumWbemClassObject* pEnumerator, const CString& cstrValueName, VARIANT& vt) { BOOL bRet = FALSE; IWbemClassObject *pclsObj = NULL; if (pEnumerator != NULL) { ULONG uReturn = 0; while (pEnumerator) { HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if(0 == uReturn || pclsObj == NULL) { break; } VARIANT vtProp; hr = pclsObj->Get(cstrValueName, 0, &vtProp, 0, 0); if (FAILED(hr)) { continue; } vt = vtProp; bRet = TRUE; break; } } if (pclsObj) { pclsObj->Release(); } return bRet; }
void CHardwareMonitor::RunWMIQuery(const char* qTable, const std::string &qType) { if ((m_pServicesOHM == NULL) || (m_pServicesSystem == NULL)) return; HRESULT hr; int dindex = 0; std::string query = "SELECT * FROM "; query.append(qTable); query.append(" WHERE SensorType = '"); query.append(qType); query.append("'"); IEnumWbemClassObject* pEnumerator = NULL; hr = m_pServicesOHM->ExecQuery(L"WQL", bstr_t(query.c_str()), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (!FAILED(hr)) { // Get the data from the query IWbemClassObject *pclsObj = NULL; while (pEnumerator) { ULONG uReturn = 0; HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (FAILED(hr) || (0 == uReturn)) { break; } VARIANT vtProp; hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0); if (SUCCEEDED(hr)) { std::string itemName = _bstr_t(vtProp.bstrVal); stdreplace(itemName, "#", ""); VariantClear(&vtProp); hr = pclsObj->Get(L"Value", 0, &vtProp, 0, 0); if (SUCCEEDED(hr)) { float fItemValue = float(vtProp.fltVal); std::ostringstream itemValue; if ((qType == "Load") || (qType == "Temperature")) { itemValue.precision(3); } itemValue << fItemValue; VariantClear(&vtProp); //hr = pclsObj->Get(L"InstanceId", 0, &vtProp, 0, 0); hr = pclsObj->Get(L"Identifier", 0, &vtProp, 0, 0); // instance id seems to drift if (SUCCEEDED(hr)) { std::string itemId = _bstr_t(vtProp.bstrVal); if (itemId.find("/hdd") != std::string::npos) { itemName = itemId + " " + itemName; } //itemId = "WMI"+itemId; //_log.Log(LOG_NORM, "Hardware Monitor: %s, %s, %s",itemId.c_str(), itemName.c_str(),itemValue.str().c_str()); UpdateSystemSensor(qType, dindex, itemName, itemValue.str()); VariantClear(&vtProp); dindex++; } } } pclsObj->Release(); } pEnumerator->Release(); } }
void WMIMonitor(ScriptValue &s, ScriptValue *args) { HRESULT hr; int i; for (i=0; i<numWmiServers; i++) { if (!scriptstrcmp(args[0].stringVal, wmiServers[i].name)) break; } if (i == numWmiServers) { if (!srealloc(wmiServers, sizeof(WMIServer)*(numWmiServers+1))) return; InitCom(); if (FAILED(CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_SECURE_REFS, NULL))) { return; } IWbemLocator *locator; hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &locator); if (FAILED(hr)) { locator = 0; UninitCom(); return; } wmiServers[i].name = args[0].stringVal; BSTR bstr = UTF8toBSTR(args[0].stringVal->value, &args[0].stringVal->len); if (!bstr) { locator->Release(); UninitCom(); return; } wmiServers[i].services = 0; hr = locator->ConnectServer(bstr, 0, 0, 0, WBEM_FLAG_CONNECT_USE_MAX_WAIT, 0, 0, &wmiServers[i].services); freeBSTR(bstr); if (FAILED(hr)) { locator->Release(); UninitCom(); return; } args[0].stringVal->AddRef(); numWmiServers++; } wmiServers[i].refs++; BSTR bstr = UTF8toBSTR(args[1].stringVal->value, &args[1].stringVal->len); if (bstr) { IEnumWbemClassObject *penum; HRESULT res = wmiServers[i].services->CreateInstanceEnum(bstr, 0, 0, &penum); if (WBEM_S_NO_ERROR == res) { IWbemClassObject *obj; ULONG returned; while ((res=penum->Next(INFINITE, 1, &obj, &returned)) == WBEM_NO_ERROR) { obj->Release(); } penum->Release(); } //wmiServers[i].services->GetObjectW(bstr, 0, 0, freeBSTR(bstr); } }
int MyMacAddress::WMI_GetMacAddress(int iQueryType, int iSize) { ZeroMemory(PermanentAddress, sizeof(PermanentAddress)); ZeroMemory(MACAddress, sizeof(MACAddress)); HRESULT hres; int iTotal = 0; if( (iQueryType < 0) || (iQueryType >= sizeof(szWQLQuery)/sizeof(T_WQL_QUERY)) ) { return -1; } hres = CoInitializeEx( NULL, COINIT_MULTITHREADED); if( FAILED(hres) ) { return -2; } hres = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL); if( FAILED(hres)) { CoUninitialize(); return -2; } IWbemLocator *pLoc = NULL; hres = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, reinterpret_cast <LPVOID*>(&pLoc)); if( FAILED(hres)) { CoUninitialize(); return -2; } IWbemServices *pSvc = NULL; hres = pLoc->ConnectServer(_bstr_t( L"ROOT\\CIMV2" ), NULL, NULL, NULL, 0, NULL, NULL, &pSvc); if( FAILED(hres)) { pLoc->Release(); CoUninitialize(); return -2; } // 设置请求代理的安全级别 hres = CoSetProxyBlanket(pSvc, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE); if(FAILED(hres)) { pSvc->Release(); pLoc->Release(); CoUninitialize(); return -2; } IEnumWbemClassObject *pEnumerator = NULL; hres = pSvc->ExecQuery(bstr_t("WQL"), bstr_t( szWQLQuery[iQueryType].szSelect), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if(FAILED(hres)) { pSvc->Release(); pLoc->Release(); CoUninitialize(); return -3; } while(pEnumerator) { IWbemClassObject *pclsObj = NULL; ULONG uReturn = 0; if(iTotal >= iSize) { break; } pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if( uReturn == 0 ) { break; } VARIANT vtProperty; TCHAR szProperty[128]; // 获取网卡范例ID VariantInit( &vtProperty); pclsObj->Get( szWQLQuery[iQueryType].szProperty, 0, &vtProperty, NULL, NULL ); StringCchCopy( szProperty, sizeof(szProperty)/sizeof(TCHAR), W2T(vtProperty.bstrVal) ); VariantClear( &vtProperty ); if( GetPNPDeviceID( szProperty)) { iTotal++; } pclsObj->Release(); } // 释放资源 pEnumerator->Release(); pSvc->Release(); pLoc->Release(); CoUninitialize(); return iTotal; }
void EnumSerialFromWMI(std::vector<int> &ports, std::vector<std::string> &friendlyNames) { ports.clear(); friendlyNames.clear(); HRESULT hr; IWbemLocator *pLocator = NULL; IWbemServices *pServicesSystem = NULL; hr = CoCreateInstance(CLSID_WbemAdministrativeLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*)&pLocator); if (FAILED(hr)) { return; } hr = pLocator->ConnectServer(L"root\\CIMV2", NULL, NULL, NULL, 0, NULL, NULL, &pServicesSystem); if (pServicesSystem == NULL) { pLocator->Release(); return; } int dindex = 0; std::string query = "SELECT * FROM Win32_PnPEntity WHERE ClassGuid=\"{4d36e978-e325-11ce-bfc1-08002be10318}\""; IEnumWbemClassObject* pEnumerator = NULL; hr = pServicesSystem->ExecQuery(L"WQL", bstr_t(query.c_str()), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); if (!FAILED(hr)) { // Get the data from the query IWbemClassObject *pclsObj = NULL; while (pEnumerator) { ULONG uReturn = 0; HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (FAILED(hr) || (0 == uReturn)) { break; } VARIANT vtProp; VariantInit(&vtProp); HRESULT hrGet = pclsObj->Get(L"Name", 0, &vtProp, NULL, NULL); if (SUCCEEDED(hrGet) && (vtProp.vt == VT_BSTR) && (wcslen(vtProp.bstrVal) > 3)) { std::string itemName = _bstr_t(vtProp.bstrVal); VariantClear(&vtProp); size_t spos = itemName.find("(COM"); if (spos != std::string::npos) { std::string tmpstr = itemName.substr(spos + 4); spos = tmpstr.find(")"); if (spos != std::string::npos) { tmpstr = tmpstr.substr(0, spos); int nPort = atoi(tmpstr.c_str()); ports.push_back(nPort); friendlyNames.push_back(itemName); } } } pclsObj->Release(); } pEnumerator->Release(); } pServicesSystem->Release(); pLocator->Release(); }
/** * Gets the switch port info from WMI (switch port friendly name, ifSpeed) * and merges into the list of existing ports. */ void readWMISwitchPorts(HSP *sp) { BSTR path = SysAllocString(WMI_VIRTUALIZATION_NS_V2); HRESULT hr = S_FALSE; IWbemServices *pNamespace = NULL; hr = connectToWMI(path, &pNamespace); if (FAILED(hr)) { //only try the v2 namespace since this will only be present //with the extensible switch that supports sampling. //don't try to get counters if there is no sampling. SysFreeString(path); myLog(LOG_INFO, "readWMISwitchPorts: virtualization namespace v2 not found"); return; } else { SysFreeString(path); } BSTR queryLang = SysAllocString(L"WQL"); wchar_t *query = L"SELECT * FROM Msvm_EthernetSwitchPort"; IEnumWbemClassObject *switchPortEnum = NULL; hr = pNamespace->ExecQuery(queryLang, query, WBEM_FLAG_FORWARD_ONLY, NULL, &switchPortEnum); SysFreeString(queryLang); if (FAILED(hr)) { myLog(LOG_ERR,"readWMISwitchPorts: ExecQuery() failed for query %S error=0x%x", query, hr); pNamespace->Release(); return; } if (sp->vAdaptorList == NULL) { sp->vAdaptorList = adaptorListNew(); } IWbemClassObject *switchPortObj = NULL; hr = WBEM_S_NO_ERROR; while (WBEM_S_NO_ERROR == hr) { SFLAdaptor *vAdaptor = NULL; ULONG uReturned = 1; hr = switchPortEnum->Next(WBEM_INFINITE, 1, &switchPortObj, &uReturned); if (0 == uReturned) { break; } wchar_t *guidString = stringFromWMIProperty(switchPortObj, PROP_NAME); if (guidString != NULL) { char portGuid[FORMATTED_GUID_LEN+1]; guidToString(guidString, (UCHAR *)portGuid, FORMATTED_GUID_LEN); myLog(LOG_INFO, "readWMISwitchPorts: portGuid=%s", portGuid); my_free(guidString); vAdaptor = adaptorListGet(sp->vAdaptorList, portGuid); } if (vAdaptor != NULL) { HVSVPortInfo *portInfo = (HVSVPortInfo *)vAdaptor->userData; wchar_t *switchName = stringFromWMIProperty(switchPortObj, PROP_SYSTEM_NAME); if (switchName != NULL) { if (portInfo->switchName != NULL) { my_free(portInfo->switchName); } portInfo->switchName = switchName; } wchar_t *friendlyName = stringFromWMIProperty(switchPortObj, PROP_ELEMENT_NAME); if (friendlyName != NULL) { if (portInfo->portFriendlyName != NULL) { my_free(portInfo->portFriendlyName); } portInfo->portFriendlyName = friendlyName; } setPortCountersInstance(vAdaptor); wchar_t *speedString = stringFromWMIProperty(switchPortObj, PROP_SPEED); if (speedString != NULL) { ULONGLONG ifSpeed = _wcstoui64(speedString, NULL, 10); vAdaptor->ifSpeed = ifSpeed; my_free(speedString); } //could also get ifDirection but FullDuplex=True always //Get the MACs and VM system name when we enumerate the vms. myLog(LOG_INFO, "readWMISwitchPorts: updated switch port %s %S portId=%u ifIndex=%u ifSpeed=%llu counterName=%S", vAdaptor->deviceName, portInfo->portFriendlyName, portInfo->portId, vAdaptor->ifIndex, vAdaptor->ifSpeed, portInfo->portCountersInstance); } else { myLog(LOG_INFO, "readWMISwitchPorts: vAdapter not found"); } switchPortObj->Release(); } switchPortEnum->Release(); pNamespace->Release(); }
bool IPodDetector::doesIpodExist(IPod *ipod) { IEnumWbemClassObject* enumerator = NULL; std::stringstream output; for( size_t i = 0; i < ipod->serial().length(); ++i ) { output << (char)ipod->serial().c_str()[i]; } queryByDeviceID( output.str(), &enumerator ); IWbemClassObject* object; ULONG count; enumerator->Next( WBEM_INFINITE, 1, &object, &count ); enumerator->Release(); if( count > 0 ) { object->Release(); return true; } return false; }