// (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; }
// Adapted mostly as-is from http://www.gamedev.net/topic/495075-how-to-retrieve-info-about-videocard/?view=findpost&p=4229170 // so credit goes to that post's author, and in turn, the author of the site mentioned in that post (which seems to be down?). std::string GetVideoCardDriverVersion() { std::string retvalue = ""; HRESULT hr; hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); if (FAILED(hr)) { return retvalue; } IWbemLocator *pIWbemLocator = NULL; hr = CoCreateInstance(__uuidof(WbemLocator), NULL, CLSCTX_INPROC_SERVER, __uuidof(IWbemLocator), (LPVOID *)&pIWbemLocator); if (FAILED(hr)) { CoUninitialize(); return retvalue; } BSTR bstrServer = SysAllocString(L"\\\\.\\root\\cimv2"); IWbemServices *pIWbemServices; hr = pIWbemLocator->ConnectServer(bstrServer, NULL, NULL, 0L, 0L, NULL, NULL, &pIWbemServices); if (FAILED(hr)) { pIWbemLocator->Release(); SysFreeString(bstrServer); CoUninitialize(); return retvalue; } hr = CoSetProxyBlanket(pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, NULL,EOAC_DEFAULT); BSTR bstrWQL = SysAllocString(L"WQL"); BSTR bstrPath = SysAllocString(L"select * from Win32_VideoController"); IEnumWbemClassObject* pEnum; hr = pIWbemServices->ExecQuery(bstrWQL, bstrPath, WBEM_FLAG_FORWARD_ONLY, NULL, &pEnum); ULONG uReturned; VARIANT var; IWbemClassObject* pObj = NULL; if (!FAILED(hr)) { hr = pEnum->Next(WBEM_INFINITE, 1, &pObj, &uReturned); } if (!FAILED(hr) && uReturned) { hr = pObj->Get(L"DriverVersion", 0, &var, NULL, NULL); if (SUCCEEDED(hr)) { char str[MAX_PATH]; WideCharToMultiByte(CP_ACP, 0, var.bstrVal, -1, str, sizeof(str), NULL, NULL); retvalue = str; } } pEnum->Release(); SysFreeString(bstrPath); SysFreeString(bstrWQL); pIWbemServices->Release(); pIWbemLocator->Release(); SysFreeString(bstrServer); CoUninitialize(); return retvalue; }
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; }
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
/* 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; }
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; }
/** * 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(); }
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; }
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; }
/* * 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; }
/** * 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(); } }
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; }
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; }
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; }
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 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; }
/* 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; }
bool ReadACL(IWbemServices *pNamespace) { bool bRet = false; _bstr_t InstPath(L"__systemsecurity=@"); _bstr_t MethName(L"GetSD"); IWbemClassObject * pOutParams = NULL; // The security descriptor is returned via the GetSD method HRESULT hr = pNamespace->ExecMethod(InstPath, MethName, 0, NULL, NULL, &pOutParams, NULL); if(SUCCEEDED(hr)) { // The output parameters has a property which has the descriptor _bstr_t prop(L"sd"); _variant_t var; hr = pOutParams->Get(prop, 0, &var, NULL, NULL); if(SUCCEEDED(hr)) { if(var.vt != (VT_ARRAY | VT_UI1)) return false; SAFEARRAY * psa = var.parray; PSECURITY_DESCRIPTOR pSD; hr = SafeArrayAccessData(psa, (void HUGEP* FAR*)&pSD); if(hr != 0) return false; // Dump out some information DumpSD(pSD); // Given that the security desciptor is now present, the code could use standard // nt functions to add or remove ace's. There are also various libraries available // that can make the job a bit easier. This sample does not change the security // descriptor, but does write it back unchanged as an example. StoreSD(pNamespace, pSD); SafeArrayUnaccessData(psa); bRet = true; } } return bRet; }
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 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(); }
int main(int argc, char **argv) { HRESULT hres; // Step 1: -------------------------------------------------- // Initialize COM. ------------------------------------------ hres = CoInitializeEx(nullptr, COINIT_MULTITHREADED); if (FAILED(hres)) { cout << "Failed to initialize COM library. Error code = 0x" << hex << hres << endl; return 1; // Program has failed. } // Step 2: -------------------------------------------------- // Set general COM security levels -------------------------- hres = CoInitializeSecurity( nullptr, -1, // COM authentication nullptr, // Authentication services nullptr, // Reserved RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation nullptr, // Authentication info EOAC_NONE, // Additional capabilities nullptr // Reserved ); if (FAILED(hres)) { cout << "Failed to initialize security. Error code = 0x" << hex << hres << endl; CoUninitialize(); return 1; // Program has failed. } // Step 3: --------------------------------------------------- // Obtain the initial locator to WMI ------------------------- IWbemLocator *pLoc = nullptr; hres = CoCreateInstance( CLSID_WbemLocator, nullptr, CLSCTX_INPROC_SERVER, IID_IWbemLocator, reinterpret_cast<LPVOID *>(&pLoc)); if (FAILED(hres)) { cout << "Failed to create IWbemLocator object." << " Err code = 0x" << hex << hres << endl; CoUninitialize(); return 1; // Program has failed. } // Step 4: ----------------------------------------------------- // Connect to WMI through the IWbemLocator::ConnectServer method IWbemServices *pSvc = nullptr; // Connect to the root\cimv2 namespace with // the current user and obtain pointer pSvc // to make IWbemServices calls. hres = pLoc->ConnectServer( _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace nullptr, // User name. NULL = current user nullptr, // User password. NULL = current nullptr, // Locale. NULL indicates current NULL, // Security flags. nullptr, // Authority (for example, Kerberos) nullptr, // Context object &pSvc // pointer to IWbemServices proxy ); if (FAILED(hres)) { cout << "Could not connect. Error code = 0x" << hex << hres << endl; pLoc->Release(); CoUninitialize(); return 1; // Program has failed. } //cout << "Connected to ROOT\\CIMV2 WMI namespace" << endl; // Step 5: -------------------------------------------------- // Set security levels on the proxy ------------------------- hres = CoSetProxyBlanket( pSvc, // Indicates the proxy to set RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx nullptr, // Server principal name RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx nullptr, // client identity EOAC_NONE // proxy capabilities ); if (FAILED(hres)) { cout << "Could not set proxy blanket. Error code = 0x" << hex << hres << endl; pSvc->Release(); pLoc->Release(); CoUninitialize(); return 1; // Program has failed. } // Step 6: -------------------------------------------------- // Use the IWbemServices pointer to make requests of WMI ---- // For example, get the name of the operating system IEnumWbemClassObject* pEnumerator = nullptr; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t("SELECT * FROM Win32_Process"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, nullptr, &pEnumerator); if (FAILED(hres)) { cout << "Query for processes failed." << " Error code = 0x" << hex << hres << endl; pSvc->Release(); pLoc->Release(); CoUninitialize(); return 1; // Program has failed. } // Step 7: ------------------------------------------------- // Get the data from the query in step 6 ------------------- IWbemClassObject *pclsObj = nullptr; ULONG uReturn = 0; int i = 0; while (pEnumerator) { i++; HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn); if (0 == uReturn) { break; } VARIANT vtId; pclsObj->Get(L"ProcessId", 0, &vtId, nullptr, nullptr); wprintf_s(L"%d\n", vtId.intVal); VARIANT vtName; pclsObj->Get(L"Name", 0, &vtName, nullptr, nullptr); if (vtName.bstrVal != nullptr) wprintf_s(L"%ls\n", vtName.bstrVal); else wprintf_s(L"\n"); VARIANT vtCmd; pclsObj->Get(L"CommandLine", 0, &vtCmd, nullptr, nullptr); if (vtCmd.bstrVal != nullptr) wprintf_s(L"%ls\n", vtCmd.bstrVal); else wprintf_s(L"\n"); VariantClear(&vtId); VariantClear(&vtName); VariantClear(&vtCmd); pclsObj->Release(); } // Cleanup // ======== pSvc->Release(); pLoc->Release(); pEnumerator->Release(); CoUninitialize(); return 0; // Program successfully completed. }
// ************************************************************************** // // CAdvClientDlg::OnDiskdetails() // // Description: // Enumerates the properties of the C: drive using the 'GetNames()' // technique. The technique uses safearrays. // // Parameters: // None. // // Returns: // Nothing. // // Globals accessed: // None. // // Globals modified: // None. // //=========================================================================== void CAdvClientDlg::OnDiskdetails() { HRESULT hRes; long lLower, lUpper, lCount; SAFEARRAY *psaNames = NULL; BSTR PropName = NULL; VARIANT varString, pVal; WCHAR *pBuf; CString clMyBuff; IWbemClassObject *pDriveInst = NULL; IWbemQualifierSet *pQualSet = NULL; VariantInit(&varString); VariantInit(&pVal); m_outputList.ResetContent(); m_outputList.AddString(_T("working...")); //------------------------------- // Get the instance for C: drive. BSTR driveName = SysAllocString(L"Win32_LogicalDisk.DeviceID=\"C:\""); if (!driveName) { TRACE(_T("SysAllocString failed: not enough memory\n")); return; } BSTR cimType = SysAllocString(L"CIMTYPE"); if (!cimType) { SysFreeString(driveName); TRACE(_T("SysAllocString failed: not enough memory\n")); return; } BSTR keyQual = SysAllocString(L"key"); if (!keyQual) { SysFreeString(driveName); SysFreeString(cimType); TRACE(_T("SysAllocString failed: not enough memory\n")); return; } if((hRes = m_pIWbemServices->GetObject(driveName, 0L, NULL, &pDriveInst, NULL)) == S_OK) { m_outputList.ResetContent(); //------------------------------- // Get the property names if((hRes = pDriveInst->GetNames(NULL, WBEM_FLAG_ALWAYS | WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames)) == S_OK) { //------------------------------- // Get the upper and lower bounds of the Names array if((hRes = SafeArrayGetLBound(psaNames, 1, &lLower)) != S_OK) { TRACE(_T("Couldn't get safe array lbound\n")); SafeArrayDestroy(psaNames); return; } //------------------------------- if((hRes = SafeArrayGetUBound(psaNames, 1, &lUpper)) != S_OK) { TRACE(_T("Couldn't get safe array ubound\n")); SafeArrayDestroy(psaNames); return; } //------------------------------- // For all properties... for (lCount = lLower; lCount <= lUpper; lCount++) { //----------------------------------------------- // I'm formatting each property as: // name (type) ==> value //----------------------------------------------- //------------------------------- // get the property name for this element if((hRes = SafeArrayGetElement(psaNames, &lCount, &PropName)) == S_OK) { clMyBuff = PropName; // print variable type for property value clMyBuff += _T(" ("); // Get pointer to property qualifiers // this mess is due to the fact that system properties don't have qualifiers if ((pDriveInst->GetPropertyQualifierSet(PropName, &pQualSet)) == S_OK) { // Get and print syntax attribute (if any) if ((pQualSet->Get(cimType, 0L, &pVal, NULL)) == S_OK) { clMyBuff += V_BSTR(&pVal); } else if (hRes != WBEM_E_NOT_FOUND) { // some other error TRACE(_T("Could not get syntax qualifier\n")); break; } VariantClear(&pVal); //------------------------------- // If this is a key field, print an asterisk if(((hRes = pQualSet->Get(keyQual, 0L, &pVal, NULL)) == S_OK) && (pVal.boolVal)) { // Yes, it's a key clMyBuff += _T(")*"); } else if (hRes == WBEM_E_NOT_FOUND) { // not a key qualifier clMyBuff += _T(")"); } else { // some other error TRACE(_T("Could not get key qualifier\n")); break; } // done with the qualifierSet. if (pQualSet) { pQualSet->Release(); pQualSet = NULL; } } else { clMyBuff += _T(")"); } //endif pDriveClass->GetPropertyQualifierSet() //------------------------------- // Get the value for the property. if((hRes = pDriveInst->Get(PropName, 0L, &varString, NULL, NULL)) == S_OK) { // Print the value clMyBuff += _T(" ==> "); clMyBuff += ValueToString(&varString, &pBuf); m_outputList.AddString(clMyBuff); free(pBuf); // allocated by ValueToString() } else { TRACE(_T("Couldn't get Property Value\n")); break; } //endif pDriveClass->Get() VariantClear(&varString); VariantClear(&pVal); } else // SafeArrayGetElement() failed { TRACE(_T("Couldn't get safe array element\n")); break; } //endif SafeArrayGetElement() } // endfor // cleanup. SysFreeString(PropName); SysFreeString(keyQual); SysFreeString(cimType); SafeArrayDestroy(psaNames); VariantClear(&varString); VariantClear(&pVal); } else // pDriveClass->GetNames() failed { TRACE(_T("Couldn't GetNames\n")); } //endif pDriveClass->GetNames() // done with drive instance. if (pDriveInst) { pDriveInst->Release(); pDriveInst = NULL; } } //endif GetObject() }
bool CSMBiosTable::FetchSMBiosDataByCom( unsigned char ** p ) { BOOL bRet = FALSE; HRESULT hres; // Initialize COM. hres = CoInitializeEx( 0, COINIT_MULTITHREADED ); if( FAILED(hres) ) { return FALSE; // Program has failed. } // Obtain the initial locator to Windows Management // on a particular host computer. IWbemLocator *pLoc = 0; hres = CoCreateInstance( CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &pLoc ); if( FAILED(hres) ) { CoUninitialize(); return FALSE; // Program has failed. } IWbemServices *pSvc = 0; // Connect to the root\cimv2 namespace with the z // current user and obtain pointer pSvc // to make IWbemServices calls. hres = pLoc->ConnectServer( _bstr_t(L"ROOT\\WMI"), // WMI namespace NULL, // User name NULL, // User password 0, // Locale NULL, // Security flags 0, // Authority 0, // Context object &pSvc // IWbemServices proxy ); if( FAILED(hres) ) { pLoc->Release(); CoUninitialize(); return FALSE; // Program has failed. } // Set the IWbemServices proxy so that impersonation // of the user (client) occurs. hres = CoSetProxyBlanket( pSvc, // the proxy to set RPC_C_AUTHN_WINNT, // authentication service RPC_C_AUTHZ_NONE, // authorization service NULL, // Server principal name RPC_C_AUTHN_LEVEL_CALL, // authentication level RPC_C_IMP_LEVEL_IMPERSONATE, // impersonation level NULL, // client identity EOAC_NONE // proxy capabilities ); if( FAILED(hres) ) { pSvc->Release(); pLoc->Release(); CoUninitialize(); return FALSE; // Program has failed. } IEnumWbemClassObject* pEnumerator = NULL; hres = pSvc->CreateInstanceEnum( L"MSSMBios_RawSMBiosTables", 0, NULL, &pEnumerator); if( FAILED(hres) ) { pSvc->Release(); pLoc->Release(); CoUninitialize(); return FALSE; // Program has failed. } else { do { IWbemClassObject* pInstance = NULL; ULONG dwCount = NULL; hres = pEnumerator->Next( WBEM_INFINITE, 1, &pInstance, &dwCount); if( SUCCEEDED(hres) ) { VARIANT varBIOSData; VariantInit(&varBIOSData); CIMTYPE type; hres = pInstance->Get(bstr_t("SmbiosMajorVersion"),0,&varBIOSData,&type,NULL); if( FAILED(hres) ) { VariantClear(&varBIOSData); } else { m_smbiosbuffer.nSMBIOSMajorVersion = varBIOSData.iVal; VariantInit(&varBIOSData); hres = pInstance->Get( bstr_t("SmbiosMinorVersion"), 0, &varBIOSData, &type, NULL ); if( FAILED(hres) ) { VariantClear( &varBIOSData ); } else { m_smbiosbuffer.nSMBIOSMinorVersion = varBIOSData.iVal; VariantInit(&varBIOSData); hres = pInstance->Get( bstr_t("SMBiosData"), 0, &varBIOSData, &type, NULL ); if( SUCCEEDED(hres) ) { if( ( VT_UI1 | VT_ARRAY ) != varBIOSData.vt ) { } else { SAFEARRAY *parray = NULL; parray = V_ARRAY(&varBIOSData); BYTE* pbData = (BYTE*)parray->pvData; m_smbiosbuffer.nLength = parray->rgsabound[0].cElements; (*p) = new unsigned char[m_smbiosbuffer.nLength]; memcpy_s( (*p), m_smbiosbuffer.nLength, pbData, m_smbiosbuffer.nLength ); bRet = TRUE; } } VariantClear( &varBIOSData ); } } break; } }while( hres == WBEM_S_NO_ERROR ); } // Cleanup // ======== pSvc->Release(); pLoc->Release(); CoUninitialize(); return bRet; }
HRESULT ExecuteMethod3InInstance( __in IWbemServices* WbemServices, __in IWbemClassObject* ClassObj, __in const BSTR InstancePath, __in ULONG InData1, __in ULONG InData2 ) { HRESULT status; IWbemClassObject* inputParamsObj = NULL; IWbemClassObject* inputParamsInstanceObj = NULL; IWbemClassObject* outputParamsInstanceObj = NULL; const BSTR methodName = SysAllocString(TOASTER_METHOD_3); VARIANT funcParam; // // Get the input parameters class objects for the method. // status = ClassObj->GetMethod(methodName, 0, &inputParamsObj, NULL); if (FAILED(status)) { goto exit; } // // Spawn an instance of the input parameters class object. // status = inputParamsObj->SpawnInstance(0, &inputParamsInstanceObj); if (FAILED(status)) { goto exit; } // // Set the input variables values (i.e., inData1, inData2 for ToasterMethod3). // funcParam.vt = VT_I4; funcParam.ulVal = InData1; status = inputParamsInstanceObj->Put(L"InData1", 0, &funcParam, 0); if (FAILED(status)) { goto exit; } funcParam.vt = VT_I4; funcParam.ulVal = InData2; status = inputParamsInstanceObj->Put(L"InData2", 0, &funcParam, 0); if (FAILED(status)) { goto exit; } // // Call the method. // printf("\n"); printf("Instance Path .: %ws\n", (wchar_t*)InstancePath); printf(" Method Name..: %ws\n", (wchar_t*)methodName); status = WbemServices->ExecMethod(InstancePath, methodName, 0, NULL, inputParamsInstanceObj, &outputParamsInstanceObj, NULL); if (FAILED(status)) { goto exit; } // // Get the "in" Parameter values from the input parameters object. // status = inputParamsInstanceObj->Get(L"InData1", 0, &funcParam, NULL, NULL); if (FAILED(status)) { goto exit; } printf(" InData1...: %d\n", funcParam.ulVal); status = inputParamsInstanceObj->Get(L"InData2", 0, &funcParam, NULL, NULL); if (FAILED(status)) { goto exit; } printf(" InData2...: %d\n", funcParam.ulVal); // // Get the "out" Parameter values from the output parameters object. // status = outputParamsInstanceObj->Get(L"OutData1", 0, &funcParam, NULL, NULL); if (FAILED(status)) { goto exit; } printf(" OutData1..: %d\n", funcParam.ulVal); status = outputParamsInstanceObj->Get(L"OutData2", 0, &funcParam, NULL, NULL); if (FAILED(status)) { goto exit; } printf(" OutData2..: %d\n", funcParam.ulVal); exit: if (methodName != NULL) { SysFreeString(methodName); } if (inputParamsObj != NULL) { inputParamsObj->Release(); } if (inputParamsInstanceObj != NULL) { inputParamsInstanceObj->Release(); } if (outputParamsInstanceObj != NULL) { outputParamsInstanceObj->Release(); } return status; }
HRESULT ExecuteMethodsInClass( __in IWbemServices* WbemServices, __in_opt PWCHAR UserId, __in_opt PWCHAR Password, __in_opt PWCHAR DomainName ) /*++ Routine Description: This routine enumerates the instances of the Toaster method class and executes the methods in the class for each instance. Arguments: WbemServices - Pointer to the WBEM services interface used for accessing the WMI services. UserId - Pointer to the user id information or NULL. Password - Pointer to password or NULL. If the user id is not specified, this parameter is ignored. DomainName - Pointer to domain name or NULL. If the user id is not specified, this parameter is ignored. Return Value: HRESULT Status code. --*/ { HRESULT status = S_OK; IEnumWbemClassObject* enumerator = NULL; IWbemClassObject* classObj = NULL; IWbemClassObject* instanceObj = NULL; const BSTR className = SysAllocString(TOASTER_METHOD_CLASS); VARIANT pathVariable; _bstr_t instancePath; ULONG nbrObjsSought = 1; ULONG nbrObjsReturned; // // Create an Enumeration object to enumerate the instances of the given class. // status = WbemServices->CreateInstanceEnum(className, WBEM_FLAG_SHALLOW | WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &enumerator); if (FAILED(status)) { goto exit; } // // Set authentication information for the interface. // status = SetInterfaceSecurity(enumerator, UserId, Password, DomainName); if (FAILED(status)) { goto exit; } // // Get the class object for the method definition. // status = WbemServices->GetObject(className, 0, NULL, &classObj, NULL); if (FAILED(status)) { goto exit; } do { // // Get the instance object for each instance of the class. // status = enumerator->Next(WBEM_INFINITE, nbrObjsSought, &instanceObj, &nbrObjsReturned); if (status == WBEM_S_FALSE) { status = S_OK; break; } if (FAILED(status)) { if (status == WBEM_E_INVALID_CLASS) { printf("ERROR: Toaster driver may not be active on the system.\n"); } goto exit; } // // To obtain the object path of the object for which the method has to be // executed, query the "__PATH" property of the WMI instance object. // status = instanceObj->Get(_bstr_t(L"__PATH"), 0, &pathVariable, NULL, NULL); if (FAILED(status)) { goto exit; } instancePath = pathVariable.bstrVal; instanceObj->Release(); instanceObj = NULL; // // Execute the methods in this instance of the class. // status = ExecuteMethod1InInstance(WbemServices, classObj, instancePath, IN_DATA1_VALUE); if (FAILED(status)) { goto exit; } status = ExecuteMethod2InInstance(WbemServices, classObj, instancePath, IN_DATA1_VALUE, IN_DATA2_VALUE); if (FAILED(status)) { goto exit; } status = ExecuteMethod3InInstance(WbemServices, classObj, instancePath, IN_DATA1_VALUE, IN_DATA2_VALUE); if (FAILED(status)) { goto exit; } } while (!FAILED(status)); exit: if (className != NULL) { SysFreeString(className); } if (classObj != NULL) { classObj->Release(); } if (enumerator != NULL) { enumerator->Release(); } if (instanceObj != NULL) { instanceObj->Release(); } return status; }
bool WMIVideoInfo::_queryPropertyWMI( const PVIQueryType queryType, const U32 adapterId, String *outValue ) { if( mServices == NULL ) return false; BSTR bstrWQL = SysAllocString(L"WQL"); BSTR bstrPath = SysAllocString(L"select * from Win32_VideoController"); IEnumWbemClassObject* enumerator; // Use the IWbemServices pointer to make requests of WMI HRESULT hr = mServices->ExecQuery(bstrWQL, bstrPath, WBEM_FLAG_FORWARD_ONLY, NULL, &enumerator); if( FAILED( hr ) ) return false; IWbemClassObject *adapter = NULL; ULONG uReturned; // Get the appropriate adapter. for ( S32 i = 0; i <= adapterId; i++ ) { hr = enumerator->Next(WBEM_INFINITE, 1, &adapter, &uReturned ); if ( FAILED( hr ) || uReturned == 0 ) { enumerator->Release(); return false; } } // Now get the property VARIANT v; hr = adapter->Get( smPVIQueryTypeToWMIString[queryType], 0, &v, NULL, NULL ); bool result = SUCCEEDED( hr ); if ( result ) { switch( v.vt ) { case VT_I4: { LONG longVal = v.lVal; if( queryType == PVI_VRAM ) longVal = longVal >> 20; // Convert to megabytes *outValue = String::ToString( (S32)longVal ); break; } case VT_UI4: { *outValue = String::ToString( (U32)v.ulVal ); break; } case VT_BSTR: { *outValue = String( v.bstrVal ); break; } case VT_LPSTR: case VT_LPWSTR: break; } } // Cleanup adapter->Release(); enumerator->Release(); return result; }
// ************************************************************************** // // CAdvClientDlg::OnEnumdisks() // // Description: // Enumerates all the disks on a machine. Demonstrates getting // known properties directly. // // Parameters: // None. // // Returns: // Nothing. // // Globals accessed: // None. // // Globals modified: // None. // //=========================================================================== void CAdvClientDlg::OnEnumdisks() { // these are for enumerating. HRESULT hRes; ULONG uReturned; IWbemClassObject *pStorageDev = NULL; IEnumWbemClassObject *pEnumStorageDevs = NULL; // these help get properties. VARIANT pVal; BSTR propName = NULL; CString buf; // here's what we're looking for. // NOTE: make sure you specify a class that has a Provider() // specified for it in the mof file. All other classes are // abstract and wont be found using HMM_FLAG_SHALLOW. They // will be found using HMM_FLAG_DEEP. BSTR className = SysAllocString(L"Win32_LogicalDisk"); if (!className) { TRACE(_T("SysAllocString failed: not enough memory\n")); return; } // setup for the "__RELPATH" system property. propName = SysAllocString(L"__RELPATH"); if (!propName) { SysFreeString(className); TRACE(_T("SysAllocString failed: not enough memory\n")); return; } VariantInit(&pVal); m_outputList.ResetContent(); m_outputList.AddString(_T("working...")); TRACE(_T("Going for class\n")); //--------------------------- // get the list of logical storage devices. if ((hRes = m_pIWbemServices->CreateInstanceEnum(className, WBEM_FLAG_SHALLOW, NULL, &pEnumStorageDevs)) == S_OK) { TRACE(_T("good enumerator\n")); m_outputList.ResetContent(); uReturned = 1; while(uReturned == 1) { //--------------------------- // enumerate through the resultset. hRes = pEnumStorageDevs->Next(TIMEOUT, 1, &pStorageDev, &uReturned); TRACE(_T("Next() %d:%s\n"), uReturned, ErrorString(hRes)); // was one found? if((hRes == S_OK) && (uReturned == 1)) { TRACE(_T("Got a device class\n")); VariantClear(&pVal); // Add the path if (pStorageDev->Get(propName, 0L, &pVal, NULL, NULL) == S_OK) { TRACE(_T("Got a device path\n")); buf = V_BSTR(&pVal); } // add to the output listbox. m_outputList.AddString(buf); // cleanup for next loop VariantInit(&pVal); // Done with this object. if (pStorageDev) { pStorageDev->Release(); // NOTE: pStorageDev MUST be set to NULL for the next all to Next(). pStorageDev = NULL; } } // endif (hRes == S_OK) } // endwhile TRACE(_T("done enumming: %s\n"), ErrorString(hRes)); // Done with this enumerator. if (pEnumStorageDevs) { pEnumStorageDevs->Release(); pEnumStorageDevs = NULL; } } else // CreateInstanceEnum() failed. { TRACE(_T("CreateInstanceEnum() failed: %s\n"), ErrorString(hRes)); } // endif CreateInstanceEnum() TRACE(_T("returning\n")); }
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 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(); } }
int wmi_get_battery_info() { std::cout << "wmi_get_battery_info" << std::endl; //assert(_initialized); //assert(pcpu_load_comp); //assert(pcpu_load_user); //assert(pcpu_load_sys); //float& cpu_load_comp = *pcpu_load_comp; //float& cpu_load_user = *pcpu_load_user; //float& cpu_load_sys = *pcpu_load_sys; IEnumWbemClassObject* enumerator = 0; IWbemClassObject* object = 0; //cpu_load_comp = 0; //cpu_load_user = 0; bool user_logged = false; long long current_process_id = _current_process_id; enumerator = request( // uint16, uint32, uint16, uint32... bstr_t("SELECT" " Availability, BatteryRechargeTime, BatteryStatus," "Caption, DesignCapacity, DesignVoltage, FullChargeCapacity" " FROM Win32_Battery") ); ULONG uReturn; for(;;) { HRESULT result = enumerator->Next(WBEM_INFINITE, 1, &object, &uReturn); if(0 == uReturn) { break; } VARIANT var; VariantInit(&var); result = object->Get(L"Voltage", 0, &var, NULL, NULL ); if (SUCCEEDED(result)) { Print(std::wcout, var); //unsigned short v = var.uiVal; //std::cout << "Availability: " << v << std::endl; } VariantInit(&var); result = object->Get(L"DischargeRate", 0, &var, NULL, NULL ); if (SUCCEEDED(result)) { Print(std::wcout, var); //unsigned int v = var.uiVal; //std::cout << "BatteryRechargeTime: " << v << std::endl; } VariantInit(&var); result = object->Get(L"Caption", 0, &var, NULL, NULL ); if (SUCCEEDED(result)) { Print(std::wcout, var); //unsigned int v = var.uiVal; //std::cout << "BatteryRechargeTime: " << v << std::endl; } VariantInit(&var); result = object->Get(L"DesignCapacity", 0, &var, NULL, NULL ); if (SUCCEEDED(result)) { Print(std::wcout, var); //unsigned int v = var.uiVal; //std::cout << "DesignCapacity: " << v << std::endl; } VariantInit(&var); result = object->Get(L"DesignVoltage", 0, &var, NULL, NULL ); if (SUCCEEDED(result)) { Print(std::wcout, var); //unsigned long long v = var.ullVal; //std::cout << "DesignVoltage: " << v << std::endl; } VariantInit(&var); result = object->Get(L"FullChargeCapacity", 0, &var, NULL, NULL ); if (SUCCEEDED(result)) { Print(std::wcout, var); //unsigned int v = var.uiVal; //std::cout << "FullChargeCapacity: " << v << std::endl; } object->Release(); } // for(;;) if (enumerator) enumerator->Release(); return 0; }