Example: Getting WMI Data from a Remote Computer

/*

Example: Getting WMI Data from a Remote Computer

You can use the procedure and code examples in this topic to create a complete WMI client application that performs COM initialization, connects to WMI on a remote computer,

 gets data semisynchronously, and then cleans up. For more information about how to get data from the local computer, see Example: Getting WMI Data from the Local Computer. 

 For more information about how to get the data asynchronously, see Example: Getting WMI Data from the Local Computer Asynchronously.

Note  If you are trying to connect to a remote computer refer to the information inConnecting to WMI Remotely.

 

The following procedure shows how to execute the WMI application. Steps 1 through 5 contain all of the steps required to set up and connect to WMI, 

and steps 6 and 7 are where data is queried and received.

Aa390422.wedge(en-us,VS.85).gifTo get WMI data from a remote computer

Initialize COM parameters with a call to CoInitializeEx.

For more information, see Initializing COM for a WMI Application.

Initialize COM process security by calling CoInitializeSecurity.

For more information, see Setting the Default Process Security Level Using C++.

Obtain the initial locator to WMI by calling CoCreateInstance.

For more information, see Creating a Connection to a WMI Namespace.

Obtain a pointer to IWbemServices for the \\root\cimv2 namespace on a remote computer by calling IWbemLocator::ConnectServer. When connecting to a remote computer, 

you need to know the computer name, domain, user name, and password of the remote computer you are connecting to. These attributes are all passed into the IWbemLocator::ConnectServer method. 

Also, ensure the user name on the computer that is trying to connect to the remote computer has the correct access privileges on the remote computer. 

For more information, see Connecting Through Windows Firewall. To connect to the local computer, see Example: Getting WMI Data from the Local Computer and Creating a Connection to a WMI Namespace.

When handling user names and passwords, it is recommended that the user be prompted for the information, use the information, and then delete the information, 

so that there is less of a chance of the information being intercepted by an unauthorized user.

 Step 4 in the example code below uses CredUIPromptForCredentials to get the user name and password, and then uses SecureZeroMemory to get rid of the information after it is used in

  IWbemLocator::ConnectServer. For more information, see Handling Passwords and Asking the User for Credentials on MSDN.

Create a COAUTHIDENTITY structure to provide credentials for setting the proxy security.

Set IWbemServices proxy security so WMI service can impersonate the client by calling CoSetProxyBlanket.

For more information, see Setting the Security Levels on a WMI Connection.

Use the IWbemServices pointer to make requests of WMI. A query is executed to obtain the name of the operating system and the amount of free physical memory by calling IWbemServices::ExecQuery.

The following WQL query is one of the method arguments.

SELECT * FROM Win32_OperatingSystem

The result of this query is stored in an IEnumWbemClassObject pointer. This allows the data objects from the query to be retrieved semisynchronously with the IEnumWbemClassObject interface. 

For more information, see Enumerating WMI. For getting the data asynchronously, see Example: Getting WMI Data from the Local Computer Asynchronously.

For more information about making requests of WMI, see Manipulating Class and Instance Information, Querying WMI, and Calling a Method.

Set IEnumWbemClassObject enumerator proxy security. Make sure to erase the credentials from memory after you have finished using them.

For more information, see Setting the Security on IWbemServices and Other Proxies.

Get and display the data from the WQL query. The IEnumWbemClassObject pointer is linked to the data objects that the query returned,

 and the data objects can be retrieved with the IEnumWbemClassObject::Next method. This method links the data objects to an IWbemClassObject pointer that is passed into the method. 

 Use the IWbemClassObject::Get method to get the desired information from the data objects.

The following code example is used to get the Name property from the data object, which provides the name of the operating system.

C++

VARIANT vtProp;

// Get the value of the Name property

hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0);

wcout << " OS Name : " << vtProp.bstrVal << endl;

Once the value of the Name property is stored in the VARIANT variable vtProp, it can then be displayed to the user.

The following code example shows how the VARIANT variable can be used again to store and display the value of the amount of free physical memory.

C++

hr = pclsObj->Get(L"FreePhysicalMemory",

    0, &vtProp, 0, 0);

wcout << " Free physical memory (in kilobytes): "

    << vtProp.uintVal << endl;

For more information, see Enumerating WMI.

For more code samples that retrieve WMI data from a remote computer, see the Check OS bitness in C++ in the MSDN Code Gallery.

The following code example shows how to get WMI data semisynchronously from a remote computer.

*/

#define _WIN32_DCOM
#define UNICODE
#include <iostream>
using namespace std;
#include <comdef.h>
#include <Wbemidl.h>
#pragma comment(lib, "wbemuuid.lib")
#pragma comment(lib, "credui.lib")
#pragma comment(lib, "comsuppw.lib")
#include <wincred.h>
#include <strsafe.h>

int __cdecl main(int argc, char **argv)
{
HRESULT hres;

// Step 1: --------------------------------------------------
// Initialize COM. ------------------------------------------

hres =  CoInitializeEx(0, 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(
NULL,
-1,                          // COM authentication
NULL,                        // Authentication services
NULL,                        // Reserved
RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
RPC_C_IMP_LEVEL_IDENTIFY,    // Default Impersonation
NULL,                        // Authentication info
EOAC_NONE,                   // Additional capabilities
NULL                         // 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 = NULL;

hres = CoCreateInstance(
CLSID_WbemLocator,
0,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator, (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 = NULL;

// Get the user name and password for the remote computer
CREDUI_INFO cui;
bool useToken = false;
bool useNTLM = true;
wchar_t pszName[CREDUI_MAX_USERNAME_LENGTH+1] = {0};
wchar_t pszPwd[CREDUI_MAX_PASSWORD_LENGTH+1] = {0};
wchar_t pszDomain[CREDUI_MAX_USERNAME_LENGTH+1];
wchar_t pszUserName[CREDUI_MAX_USERNAME_LENGTH+1];
wchar_t pszAuthority[CREDUI_MAX_USERNAME_LENGTH+1];
BOOL fSave;
DWORD dwErr;

memset(&cui,0,sizeof(CREDUI_INFO));
cui.cbSize = sizeof(CREDUI_INFO);
cui.hwndParent = NULL;
// Ensure that MessageText and CaptionText identi
4000
fy
// what credentials to use and which application requires them.
cui.pszMessageText = TEXT("Press cancel to use process token");
cui.pszCaptionText = TEXT("Enter Account Information");
cui.hbmBanner = NULL;
fSave = FALSE;

dwErr = CredUIPromptForCredentials(
&cui,                             // CREDUI_INFO structure
TEXT(""),                         // Target for credentials
NULL,                             // Reserved
0,                                // Reason
pszName,                          // User name
CREDUI_MAX_USERNAME_LENGTH+1,     // Max number for user name
pszPwd,                           // Password
CREDUI_MAX_PASSWORD_LENGTH+1,     // Max number for password
&fSave,                           // State of save check box
CREDUI_FLAGS_GENERIC_CREDENTIALS |// flags
CREDUI_FLAGS_ALWAYS_SHOW_UI |
CREDUI_FLAGS_DO_NOT_PERSIST);

if(dwErr == ERROR_CANCELLED)
{
useToken = true;
}
else if (dwErr)
{
cout << "Did not get credentials " << dwErr << endl;
pLoc->Release();
CoUninitialize();
return 1;
}

// change the computerName strings below to the full computer name
// of the remote computer
if(!useNTLM)
{
StringCchPrintf(pszAuthority, CREDUI_MAX_USERNAME_LENGTH+1, L"kERBEROS:%s", L"COMPUTERNAME");
}

// Connect to the remote root\cimv2 namespace
// and obtain pointer pSvc to make IWbemServices calls.
//---------------------------------------------------------

hres = pLoc->ConnectServer(
_bstr_t(L"\\\\COMPUTERNAME\\root\\cimv2"),
_bstr_t(useToken?NULL:pszName),    // User name
_bstr_t(useToken?NULL:pszPwd),     // User password
NULL,                              // Locale
NULL,                              // Security flags
_bstr_t(useNTLM?NULL:pszAuthority),// Authority
NULL,                              // Context object
&pSvc                              // 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: --------------------------------------------------
// Create COAUTHIDENTITY that can be used for setting security on proxy

COAUTHIDENTITY *userAcct =  NULL ;
COAUTHIDENTITY authIdent;

if( !useToken )
{
memset(&authIdent, 0, sizeof(COAUTHIDENTITY));
authIdent.PasswordLength = wcslen (pszPwd);
authIdent.Password = (USHORT*)pszPwd;

LPWSTR slash = wcschr (pszName, L'\\');
if( slash == NULL )
{
cout << "Could not create Auth identity. No domain specified\n" ;
pSvc->Release();
pLoc->Release();
CoUninitialize();
return 1;               // Program has failed.
}

StringCchCopy(pszUserName, CREDUI_MAX_USERNAME_LENGTH+1, slash+1);
authIdent.User = (USHORT*)pszUserName;
authIdent.UserLength = wcslen(pszUserName);

StringCchCopyN(pszDomain, CREDUI_MAX_USERNAME_LENGTH+1, pszName, slash - pszName);
authIdent.Domain = (USHORT*)pszDomain;
authIdent.DomainLength = slash - pszName;
authIdent.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;

userAcct = &authIdent;

}

// Step 6: --------------------------------------------------
// Set security levels on a WMI connection ------------------

hres = CoSetProxyBlanket(
pSvc,                           // Indicates the proxy to set
RPC_C_AUTHN_DEFAULT,            // RPC_C_AUTHN_xxx
RPC_C_AUTHZ_DEFAULT,            // RPC_C_AUTHZ_xxx
COLE_DEFAULT_PRINCIPAL,         // Server principal name
RPC_C_AUTHN_LEVEL_PKT_PRIVACY,  // RPC_C_AUTHN_LEVEL_xxx
RPC_C_IMP_LEVEL_IMPERSONATE,    // RPC_C_IMP_LEVEL_xxx
userAcct,                       // 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 7: --------------------------------------------------
// Use the IWbemServices pointer to make requests of WMI ----

// For example, get the name of the operating system
IEnumWbemClassObject* pEnumerator = NULL;
hres = pSvc->ExecQuery(
bstr_t("WQL"),
bstr_t("Select * from Win32_OperatingSystem"),
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
NULL,
&pEnumerator);

if (FAILED(hres))
{
cout << "Query for operating system name failed."
<< " Error code = 0x"
<< hex << hres << endl;
pSvc->Release();
pLoc->Release();
CoUninitialize();
return 1;               // Program has failed.
}

// Step 8: -------------------------------------------------
// Secure the enumerator proxy
hres = CoSetProxyBlanket(
pEnumerator,                    // Indicates the proxy to set
RPC_C_AUTHN_DEFAULT,            // RPC_C_AUTHN_xxx
RPC_C_AUTHZ_DEFAULT,            // RPC_C_AUTHZ_xxx
COLE_DEFAULT_PRINCIPAL,         // Server principal name
RPC_C_AUTHN_LEVEL_PKT_PRIVACY,  // RPC_C_AUTHN_LEVEL_xxx
RPC_C_IMP_LEVEL_IMPERSONATE,    // RPC_C_IMP_LEVEL_xxx
userAcct,                       // client identity
EOAC_NONE                       // proxy capabilities
);

if (FAILED(hres))
{
cout << "Could not set proxy blanket on enumerator. Error code = 0x"
<< hex << hres << endl;
pEnumerator->Release();
pSvc->Release();
pLoc->Release();
CoUninitialize();
return 1;               // Program has failed.
}

// When you have finished using the credentials,
// erase them from memory.
SecureZeroMemory(pszName, sizeof(pszName));
SecureZeroMemory(pszPwd, sizeof(pszPwd));
SecureZeroMemory(pszUserName, sizeof(pszUserName));
SecureZeroMemory(pszDomain, sizeof(pszDomain));

// Step 9: -------------------------------------------------
// Get the data from the query in step 7 -------------------

IWbemClassObject *pclsObj = NULL;
ULONG uReturn = 0;

while (pEnumerator)
{
HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
&pclsObj, &uReturn);

if(0 == uReturn)
{
break;
}

VARIANT vtProp;

// Get the value of the Name property
hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
wcout << " OS Name : " << vtProp.bstrVal << endl;

// Get the value of the FreePhysicalMemory property
hr = pclsObj->Get(L"FreePhysicalMemory",
0, &vtProp, 0, 0);
wcout << " Free physical memory (in kilobytes): "
<< vtProp.uintVal << endl;
VariantClear(&vtProp);

pclsObj->Release();
pclsObj = NULL;
}

// Cleanup
// ========

pSvc->Release();
pLoc->Release();
pEnumerator->Release();
if( pclsObj )
{
pclsObj->Release();
}

CoUninitialize();

return 0;   // Program successfully completed.

}