|
|
#include "testwmi.h"
//
// The function connects to the namespace.
//
IWbemServices *ConnectToNamespace (VOID){ IWbemServices *pIWbemServices = NULL; IWbemLocator *pIWbemLocator = NULL; HRESULT hr;
//
// Create an instance of WbemLocator interface.
//
hr = CoCreateInstance( CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *)&pIWbemLocator ); if ( hr == S_OK ) {
//
// Using the locator, connect to COM in the given namespace.
//
hr = pIWbemLocator->ConnectServer( DEFAULT_NAMESPACE, NULL, // current account.
NULL, // current password.
0L, // locale
0L, // securityFlags
NULL, // domain for NTLM
NULL, // context
&pIWbemServices );
if ( hr == WBEM_S_NO_ERROR) { //
// Switch the security level to IMPERSONATE so that provider(s)
// will grant access to system-level objects, and so that
// CALL authorization will be used.
//
hr = CoSetProxyBlanket( (IUnknown *)pIWbemServices, // proxy
RPC_C_AUTHN_WINNT, // authentication service
RPC_C_AUTHZ_NONE, // authorization service
NULL, // server principle name
RPC_C_AUTHN_LEVEL_CALL, // authentication level
RPC_C_IMP_LEVEL_IMPERSONATE, // impersonation
NULL, // identity of the client
EOAC_NONE ); // capability flags
if ( hr != S_OK ) {
pIWbemServices->Release(); pIWbemServices = NULL;
PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't impersonate, program exiting...") ); } } else { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't connect to root\\wmi, program exiting...") ); }
//
// Done with IWbemLocator.
//
pIWbemLocator->Release(); } else { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't create an instance of ") TEXT("IWbemLocator interface, programm exiting...") ); }
return pIWbemServices;}
//
// Given a class name, the function populates the combo box with all
// the instances of the class.
//
VOID EnumInstances (IWbemServices *pIWbemServices, LPTSTR lpszClass, HWND hwndInstTree){ IEnumWbemClassObject *pEnumInst; IWbemClassObject *pInst; VARIANT varInstanceName; BSTR bstrClass; LPTSTR lpszInstance; ULONG ulFound; HRESULT hr;
bstrClass = StringToBstr( lpszClass, -1 ); if ( !bstrClass ) {
PrintError( HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY), __LINE__, TEXT(__FILE__), TEXT("Not enough memory to enumerate instances of %s"), lpszClass );
return; }
hr = pIWbemServices->CreateInstanceEnum( bstrClass, // Name of the root class.
WBEM_FLAG_SHALLOW | // Enumerate at current root only.
WBEM_FLAG_FORWARD_ONLY, // Forward-only enumeration.
NULL, // Context.
&pEnumInst ); // pointer to class enumerator
if ( hr == WBEM_S_NO_ERROR ) {
//
// Begin enumerating instances.
//
ulFound = 0;
hr = pEnumInst->Next( 2000, // two seconds timeout
1, // return just one instance.
&pInst, // pointer to instance.
&ulFound); // Number of instances returned.
while ( (hr == WBEM_S_NO_ERROR) && (ulFound == 1) ) {
VariantInit( &varInstanceName );
//
// Get the instance name stored in __RELPATH property.
//
hr = pInst->Get( L"__RELPATH", // property name
0L, // Reserved, must be zero.
&varInstanceName, // property value returned.
NULL, // CIM type not needed.
NULL ); // Flavor not needed.
if ( hr == WBEM_S_NO_ERROR ) {
lpszInstance = BstrToString( V_BSTR(&varInstanceName), -1 ); if ( lpszInstance ) {
InsertItem( hwndInstTree, lpszInstance );
SysFreeString( (BSTR)lpszInstance ); } else { hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Out of memory while enumerating instaces of") TEXT(" %s, no more instances will") TEXT(" be listed."), lpszClass ); }
VariantClear( &varInstanceName ); } else { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't retrieve __RELPATH of an instance") TEXT(" of %s, no more instances will be listed."), lpszClass ); }
//
// Done with this instance.
//
pInst->Release();
if ( hr == WBEM_S_NO_ERROR ) {
hr = pEnumInst->Next( 2000, // two seconds timeout.
1, // return just one class.
&pInst, // pointer to returned class.
&ulFound); // Number of classes returned.
} } pEnumInst->Release();
} else { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't create an instance of ") TEXT("IEnumWbemClassObject interface, instances of %s ") TEXT("will not be listed."), lpszClass ); }
SysFreeString( bstrClass );
return;}
//
// Given a class name and __RELPATH of an instance, the function lists all the
// local non-system properties in a tree list.
//
VOID EnumProperties (IWbemServices *pIWbemServices, LPTSTR lpszClass, LPTSTR lpszInstance, HWND hwndPropTree){ IWbemClassObject *pInst; SAFEARRAY *psaPropNames; BSTR bstrProperty; long lLower; long lUpper; long i; HRESULT hr; LPTSTR lpszProperty;
//
// Get a pointer to the instance.
//
pInst = GetInstanceReference( pIWbemServices, lpszClass, lpszInstance );
if ( pInst ) {
//
// psaPropNames must be null prior to making the call.
//
psaPropNames = NULL;
//
// Get all the properties.
//
hr = pInst->GetNames( NULL, // No qualifier names.
WBEM_FLAG_ALWAYS | // All non-system properties
WBEM_FLAG_LOCAL_ONLY, NULL, // No qualifier values.
&psaPropNames); // Returned property names
if ( hr == WBEM_S_NO_ERROR ) {
//
// Get the number of properties returned.
//
SafeArrayGetLBound( psaPropNames, 1, &lLower ); SafeArrayGetUBound( psaPropNames, 1, &lUpper );
//
// List all properties or stop when encountered an error.
//
for (i=lLower; (hr == WBEM_S_NO_ERROR) && (i <= lUpper); i++) {
//
// Add the property name into the list box.
//
bstrProperty = NULL;
hr = SafeArrayGetElement( psaPropNames, &i, &bstrProperty);
if ( SUCCEEDED(hr) ) {
lpszProperty = BstrToString( bstrProperty, -1 );
if ( lpszProperty ) {
InsertItem( hwndPropTree, lpszProperty );
SysFreeString( (BSTR)lpszProperty ); } else { PrintError( HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY), __LINE__, TEXT(__FILE__), TEXT("Out of memory while enumerating") TEXT(" properties of %s, no more properties") TEXT(" will be listed"), lpszInstance ); }
//
// Done with the property name.
//
SysFreeString( bstrProperty ); } else { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't get the name of a property(%d). ") TEXT("No more properties will be listed."), i ); } }
//
// Done with the array of properties.
//
SafeArrayDestroy( psaPropNames ); } else { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't retrieve the properties of %s, ") TEXT("an instance of class %s. Properties will not be ") TEXT("listed."), lpszInstance, lpszClass ); }
} else { PrintError( HRESULT_FROM_WIN32(ERROR_WMI_INSTANCE_NOT_FOUND), __LINE__, TEXT(__FILE__), TEXT("Couldn't retrieve a pointer to instance %s of class %s.") TEXT("Its properties will not be listed."), lpszInstance, lpszClass ); }
return;}
//
// Given a class name and __RELPATH of an instance, the function returns a
// pointer to the instance.
//
IWbemClassObject *GetInstanceReference (IWbemServices *pIWbemServices, LPTSTR lpszClass, LPTSTR lpszInstance){ IWbemClassObject *pInst; IEnumWbemClassObject *pEnumInst; ULONG ulCount; BSTR bstrClass; BOOL bFound; HRESULT hr;
hr = 0;
bstrClass = StringToBstr( lpszClass, -1 ); if ( !bstrClass ) {
PrintError( HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY), __LINE__, TEXT(__FILE__), TEXT("Not enough memory to get a pointer to %s."), lpszInstance );
return NULL; }
//
// pInst pointer must be NULL initially,
//
pInst = NULL;
//
// Get Instance Enumerator Interface.
//
pEnumInst = NULL;
hr = pIWbemServices->CreateInstanceEnum(bstrClass, WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY, NULL, &pEnumInst );
if ( hr == WBEM_S_NO_ERROR ) {
//
// Get a pointer to the instance.
//
// We enumerate all the instances and compare their __RELPATH with
// the specified __RELPATH. If we find a match then, that is the one
// we are looking for.
//
// The other more efficient way is to create a WQL query and execute
// it.
//
hr = WBEM_S_NO_ERROR; bFound = FALSE;
while ( (hr == WBEM_S_NO_ERROR) && (bFound == FALSE) ) {
hr = pEnumInst->Next( 2000, // two seconds timeout
1, // return just one instance.
&pInst, // pointer to instance.
&ulCount); // Number of instances returned.
if ( ulCount > 0 ) {
bFound = IsInstance( pInst, lpszInstance );
if ( bFound == FALSE ) { pInst->Release(); } } }
if ( bFound == FALSE ) pInst = NULL;
//
// Done with the instance enumerator.
//
pEnumInst->Release(); }
SysFreeString( bstrClass ); return pInst;}
//
// Given a pointer, the function returns TRUE if the pointer points to
// the instance specified by lpszInstance.
//
BOOL IsInstance (IWbemClassObject *pInst, LPTSTR lpszInstance){ VARIANT varPropVal; LPTSTR lpInstance; BOOL bRet;
bRet = GetPropertyValue( pInst, TEXT("__RELPATH"), &varPropVal, NULL );
if ( bRet == TRUE ) {
lpInstance = BstrToString( V_BSTR(&varPropVal), -1 ); if ( !lpInstance ) {
PrintError( HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY), __LINE__, TEXT(__FILE__), TEXT("Not enough memory to search for an instance.") );
bRet = FALSE; } else { bRet = _tcsicmp( lpszInstance, lpInstance ) == 0;
SysFreeString( (BSTR)lpInstance ); }
VariantClear( &varPropVal ); }
return bRet;}
//
// The function returns property value and its type of a given class/instance.
//
BOOL GetPropertyValue (IWbemClassObject *pRef, LPTSTR lpszProperty, VARIANT *pvaPropertyValue, LPTSTR *lppszPropertyType){ IWbemQualifierSet *pQual; VARIANT vaQual; BSTR bstrProperty; HRESULT hr; BOOL bRet;
//
// Get the property value.
//
bstrProperty = StringToBstr( lpszProperty, -1 );
if ( !bstrProperty ) {
return FALSE;
}
bRet = FALSE;
if ( lppszPropertyType ) {
//
// Get the textual name of the property type.
//
hr = pRef->GetPropertyQualifierSet( bstrProperty, &pQual );
if ( hr == WBEM_S_NO_ERROR ) {
//
// Get the textual name of the property type.
//
hr = pQual->Get( L"CIMTYPE", 0, &vaQual, NULL );
if ( hr == WBEM_S_NO_ERROR ) { *lppszPropertyType = BstrToString( V_BSTR(&vaQual), -1 );
VariantClear( &vaQual ); }
pQual->Release(); } }
VariantInit( pvaPropertyValue );
hr = pRef->Get( bstrProperty, 0, pvaPropertyValue, NULL, NULL );
if ( hr == WBEM_S_NO_ERROR ) { bRet = TRUE; } else { if ( lppszPropertyType && *lppszPropertyType ) { SysFreeString( (BSTR)*lppszPropertyType ); } }
SysFreeString( bstrProperty ); return bRet;}
//
// Given a pointer to an instance, its property and and variant specifying
// the value for the property, the function updates the property and the
// instance.
//
HRESULT UpdatePropertyValue (IWbemServices *pIWbemServices, IWbemClassObject *pInstance, LPTSTR lpszProperty, LPVARIANT pvaNewValue){ BSTR bstrProperty; HRESULT hr;
bstrProperty = StringToBstr( lpszProperty, -1 );
if ( !bstrProperty ) {
PrintError( HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY), __LINE__, TEXT(__FILE__), TEXT("Not enough memory to update %s."), lpszProperty );
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY); } hr = pInstance->Put( bstrProperty, 0, pvaNewValue, 0 );
if ( hr == WBEM_S_NO_ERROR ) { hr = pIWbemServices->PutInstance( pInstance, WBEM_FLAG_UPDATE_ONLY, NULL, NULL );
if ( hr != WBEM_S_NO_ERROR ) { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Failed to save the instance,") TEXT(" %s will not be updated."), lpszProperty ); } } else { PrintError( hr, __LINE__, TEXT(__FILE__), TEXT("Couldn't update %s."), lpszProperty ); }
SysFreeString( bstrProperty );
return hr;}
BSTR StringToBstr (LPTSTR lpSrc, int nLenSrc){ BSTR lpDest;
//
// In case of ANSI version, we need to change the ANSI string to UNICODE since
// BSTRs are essentially UNICODE strings.
//
#if !defined(UNICODE) || !defined(_UNICODE)
int nLenDest;
nLenDest = MultiByteToWideChar( CP_ACP, 0, lpSrc, nLenSrc, NULL, 0);
lpDest = SysAllocStringLen( NULL, nLenDest );
if ( lpDest ) { MultiByteToWideChar( CP_ACP, 0, lpSrc, nLenSrc, lpDest, nLenDest ); }
//
// In case of UNICODE version, we simply allocate memory and copy the string.
//
#else
if ( lpSrc == NULL ) { nLenSrc = 0; } else { if ( nLenSrc == -1 ) { nLenSrc = _tcslen( lpSrc ) + sizeof(TCHAR); } }
lpDest = SysAllocStringLen( lpSrc, nLenSrc ); #endif
return lpDest;}
//
// The function converts a BSTR string into ANSI and returns it in an allocated
// memory. The memory must be freed by the caller using SysFreeString()
// function. If nLenSrc is -1, the string is null terminated.
//
LPTSTR BstrToString (BSTR lpSrc, int nLenSrc){ LPTSTR lpDest;
//
// In case of ANSI version, we need to change BSTRs which are UNICODE strings
// into ANSI version.
//
#if !defined(UNICODE) || !defined(_UNICODE)
int nLenDest;
nLenDest = WideCharToMultiByte( CP_ACP, 0, lpSrc, nLenSrc, NULL, 0, NULL, NULL ); lpDest = (LPTSTR)SysAllocStringLen( NULL, (size_t)nLenDest );
if ( lpDest ) { WideCharToMultiByte( CP_ACP, 0, lpSrc, nLenSrc, lpDest, nLenDest, NULL, NULL ); } //
// In case of UNICODE version, we simply allocate memory and copy the BSTR
// into allocate memory and return its address.
//
#else
if ( lpSrc ) { if ( nLenSrc == -1 ) { nLenSrc = _tcslen( lpSrc ) + sizeof(TCHAR); } } else { nLenSrc = 0; }
lpDest = (LPTSTR)SysAllocStringLen( lpSrc, nLenSrc ); #endif
return lpDest;}
|
