EmptyCrate Software. Travel. Stuff.

#include <vector>
#include <string>
#include <sstream>
#include <map>
 
#define _WIN32_DCOM
#include <iostream>
using namespace std;
#include <comdef.h>
#include <Wbemidl.h>
 
# pragma comment(lib, "wbemuuid.lib")
 
std::wstring str_to_wstr( const std::string& str )
{
  std::wstring wstr( str.length()+1, 0 );
 
  MultiByteToWideChar( CP_ACP,
             0,
             str.c_str(),
             str.length(),
             &wstr[0],
             str.length() );
 
  wstr.resize(str.length());
 
  return wstr;
}
 
std::string wstr_to_str( const std::wstring& wstr )
{
  size_t size = wstr.length();
  std::string str( size + 1, 0 );
 
  WideCharToMultiByte( CP_ACP,
             0,
             wstr.c_str(),
             size,
             &str[0],
             size,
             NULL,
             NULL );
 
  str.resize(wstr.length());
 
  return str;
}
 
template<typename T>
  std::string to_string(const T &t)
  {
    std::stringstream ss;
    ss << t;
    return ss.str();
  }
 
struct WMI
{ 
  typedef std::vector<std::map<std::string, std::string> > Dataset;
 
  //Struct to initialize and deinitialize COM state.
  struct CoInitializeGuard
  {
    CoInitializeGuard()
    {
      // Initialize COM.
      HRESULT hres =  CoInitializeEx(0, COINIT_MULTITHREADED);
      if (FAILED(hres))
      {
        throw std::runtime_error("Failed to initialize COM Library. Error code " + to_string(hres));
      }
    }
 
    ~CoInitializeGuard()
    {
      CoUninitialize();
    }
  };
 
  //Manages call to CoInitializedSecurity
  struct CoInitializeSecurityGuard
  {
    CoInitializeSecurityGuard()
    {
      // Initialize
      HRESULT hres =  CoInitializeSecurity(
        NULL,    
        -1,      // COM negotiates service                 
        NULL,    // Authentication services
        NULL,    // Reserved
        RPC_C_AUTHN_LEVEL_DEFAULT,    // authentication
        RPC_C_IMP_LEVEL_IMPERSONATE,  // Impersonation
        NULL,             // Authentication info
        EOAC_NONE,        // Additional capabilities
        NULL              // Reserved
        );
 
 
      if (FAILED(hres))
      {
        throw std::runtime_error("Failed to initialize security. Error code " + to_string(hres));
      }
    }
 
    ~CoInitializeSecurityGuard()
    {
    }
  };
 
  //Manages lifetime of IWbemLocator object
  struct CoCreateInstanceGuard
  {
    // Obtain the initial locator to Windows Management
    // on a particular host computer.
    IWbemLocator *pLoc;
 
    CoCreateInstanceGuard()
      : pLoc(0)
    {
      HRESULT hres = CoCreateInstance(
        CLSID_WbemLocator,            
        0,
        CLSCTX_INPROC_SERVER,
        IID_IWbemLocator, (LPVOID *) &pLoc);
 
      if (FAILED(hres))
      {
        throw std::runtime_error("Failed to create IWbemLocator object. Error code " + to_string(hres));
      }
    }
 
    ~CoCreateInstanceGuard()
    {
      pLoc->Release();    
    }
  };
 
  //Manages lifetime of IWbemServices object
  struct ConnectServerGuard
  {
    IWbemServices *pSvc;
    ConnectServerGuard(IWbemLocator *pLoc)
      : pSvc(0)
    {
      // Connect to the root\cimv2 namespace with the
      // current user and obtain pointer pSvc
      // to make IWbemServices calls.
      HRESULT hres = pLoc->ConnectServer(
        _bstr_t(L"ROOT\\CIMV2"), // WMI namespace
        NULL,                    // User name
        NULL,                    // User password
        0,                       // Locale
        NULL,                    // Security flags                
        0,                       // Authority      
        0,                       // Context object
        &pSvc                    // IWbemServices proxy
        );                             
 
      if (FAILED(hres))
      {
        throw std::runtime_error("Could not connect to WMI Server. Error code " + to_string(hres));
      }
    }
    ~ConnectServerGuard()
    {
      pSvc->Release();
    }
  };
 
  //Manages call to CoSetProxyBlanket
  struct CoSetProxyBlanketGuard
  {
    CoSetProxyBlanketGuard(IWbemServices *pSvc)
    {
      // Set the IWbemServices proxy so that impersonation
      // of the user (client) occurs.
      HRESULT 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))
      {
        throw std::runtime_error("Could not set proxy blanket. Error code " + to_string(hres));
      }
    }
    ~CoSetProxyBlanketGuard()
    {
    }
  };
 
  CoInitializeGuard cig;
  CoInitializeSecurityGuard cisg;
  CoCreateInstanceGuard ccig;
  ConnectServerGuard csg;
  CoSetProxyBlanketGuard cspb;
 
  //By using RAII WMI is only created if all phases succeed.
  //if any piece fails then the resources are freed that did succeed
  //during stack unrolling of the WMI object.
  //
  //Also, the destruction of the WMI object under normal circumstances
  //similarly results in the unrolling of each piece and the resources being
  //returned.
  WMI()
    : csg(ccig.pLoc), cspb(csg.pSvc)
  { 
  }
 
  void runQuery(const std::string &query)
  {
    // Use the IWbemServices pointer to make requests of WMI.
    // Make requests here:
 
    // For example, query for all the running processes
    IEnumWbemClassObject* pEnumerator = NULL;
 
    HRESULT hres = csg.pSvc->ExecQuery(
      bstr_t("WQL"),
      bstr_t(query.c_str()),
      WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
      NULL,
      &pEnumerator);
 
    if (FAILED(hres))
    {
      throw std::runtime_error("WMI query failed. Error code " + to_string(hres));
    }
    else
    {
      IWbemClassObject *pclsObj;
      ULONG uReturn = 0;
 
      while (pEnumerator)
      {
        hres = pEnumerator->Next(WBEM_INFINITE, 1,
          &pclsObj, &uReturn);
 
        if(0 == uReturn)
        {
          break;
        }
 
        if (pclsObj->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY) == WBEM_S_NO_ERROR)
        {
          BSTR name;
          VARIANT value;
 
          while (pclsObj->Next(0, &name, &value,0,0) == WBEM_S_NO_ERROR)
          {
            // Get the value of the Name property
 
            VariantChangeType(&value, &value, 0, VT_BSTR);
 
            //Note: unicode characters are not transliterated, the are preserved if they
            // exist and may case display problems.           
            cout << wstr_to_str(name) << ": " << (value.vt==VT_BSTR)?wstr_to_str(value.bstrVal):"" << endl;
            VariantClear(&value);
            SysFreeString(name);
          }
 
          pclsObj->Release();
        }
      }
      pEnumerator->Release();
    }
  }
};
 
int main(int argc, char* argv[])
{
    WMI wmi;
    wmi.runQuery("select Dependent from win32_usbcontrollerdevice");
 
  return 0;   // Program successfully completed.
}