// **************************************************************************
//
//	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()
}
Esempio n. 2
0
IWbemClassObject* CConsumer::GetEventClass(IWbemClassObject* pEventCategoryClass, int EventType)
{
	HRESULT hr = S_OK;
	HRESULT hrQualifier = S_OK;
	IEnumWbemClassObject *pClasses = NULL;
	IWbemClassObject *pClass = NULL;
	IWbemQualifierSet *pQualifiers = NULL;
	VARIANT varClassName;
	VARIANT varEventType;
	ULONG cnt = 0;
	BOOL FoundEventClass = FALSE;

	hr = pEventCategoryClass->Get(L"__RELPATH", 0, &varClassName,NULL,NULL);
	if(FAILED(hr))
	{ 
		wprintf(L"pEventCategory->Get failed with 0x%x\r\n", hr);
		goto cleanup;
	}
	hr = g_pServices->CreateClassEnum(varClassName.bstrVal,
		WBEM_FLAG_SHALLOW | WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_USE_AMENDED_QUALIFIERS,
		NULL, &pClasses);

	if(FAILED(hr))
	{
		wprintf(L"g_pServices->CreateClassEnum failed with 0x%x\r\n", hr);
		goto cleanup;
	}

	while(S_OK == hr)
	{
		hr = pClasses->Next(WBEM_INFINITE,1, &pClass, &cnt);
		if(FAILED(hr))
		{
			wprintf(L"pClass->Next Failed with 0x%x\r\n", hr);
			goto cleanup;
		}
		if(!pClass)
			continue;
		hrQualifier = pClass->GetQualifierSet(&pQualifiers);
		if(FAILED(hrQualifier))
		{
			wprintf(L"pClass->GetQualifierSet Failed with 0x%x\r\n", hrQualifier);
			pClass->Release();
			pClass = NULL;
			goto cleanup;
		}

		hrQualifier = pQualifiers->Get(L"EventType", 0, &varEventType, NULL);
		if(FAILED(hrQualifier))
		{
			wprintf(L"pQualifiers->Get Failed with 0x%x\r\n", hrQualifier);
			pQualifiers->Release();
			pQualifiers = NULL;
			pClass->Release();
			pClass = NULL;
			goto cleanup;
		}

		// If multiple events provide the same data, the EventType qualifier
		// will contain an array of types. Loop through the array and find a match.

		if (varEventType.vt & VT_ARRAY)
		{
			HRESULT hrSafe = S_OK;
			int ClassEventType;
			SAFEARRAY* pEventTypes = varEventType.parray;

			for (LONG i=0; (ULONG)i < pEventTypes->rgsabound->cElements; i++)
			{
				hrSafe = SafeArrayGetElement(pEventTypes, &i, &ClassEventType);

				if (ClassEventType == EventType)
				{
					FoundEventClass = TRUE;
					break;  //for loop
				}
			}
		}
		else
		{
			if (varEventType.intVal == EventType)
			{
				FoundEventClass = TRUE;
			}
		}

		VariantClear(&varEventType);

		if (TRUE == FoundEventClass)
		{
			break;  //while loop
		}

		pClass->Release();
		pClass = NULL;

	}
cleanup:
	if (pClasses)
	{
		pClasses->Release();
		pClasses = NULL;
	}

	if (pQualifiers)
	{
		pQualifiers->Release();
		pQualifiers = NULL;
	}

	VariantClear(&varClassName);
	VariantClear(&varEventType);

	return pClass;
}
Esempio n. 3
0
IWbemClassObject* CConsumer::GetEventCategoryClass(BSTR bstrclassGuid, int Version)
{
	HRESULT hr = S_OK;
	HRESULT hrQualifier = S_OK;
	IEnumWbemClassObject* pClasses = NULL;
	IWbemClassObject* pClass = NULL;
	IWbemQualifierSet* pQualifiers = NULL;
	ULONG cnt = 0;
	VARIANT varGuid;
	VARIANT varVersion;

	hr = g_pServices->CreateClassEnum(_bstr_t(L"EventTrace"),
		WBEM_FLAG_DEEP | WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_USE_AMENDED_QUALIFIERS,
		NULL, &pClasses);

	if(FAILED(hr))
	{
		wprintf(L"CreateClassEnum failed with 0x%x\r\n", hr);
		goto cleanup;
	}
	while(S_OK == hr)
	{
		hr = pClasses->Next(WBEM_INFINITE, 1, &pClass, &cnt);
		if(FAILED(hr))
		{
			wprintf(L"pClasses->Next Failed with 0x%x\r\n", hr);
			goto cleanup;
		}
		hrQualifier = pClass->GetQualifierSet(&pQualifiers);
		if(pQualifiers)
		{
			hrQualifier = pQualifiers->Get(L"Guid", 0, &varGuid, NULL);
			if(SUCCEEDED(hrQualifier) && 0 == _wcsicmp(varGuid.bstrVal, bstrclassGuid))
			{
				hrQualifier = pQualifiers->Get(L"EventVersion", 0, &varVersion, NULL);
				if(SUCCEEDED(hrQualifier))
				{
					if(Version == varVersion.intVal)
					{
						break;
					}
					VariantClear(&varVersion);
				}
				else if(WBEM_E_NOT_FOUND == hrQualifier)
				{
					break;
				}
				VariantClear(&varGuid);
			}
			pQualifiers->Release();
			pQualifiers = NULL;
		}
		pClass->Release();
		pClass = NULL;
	}
cleanup:
	if(pClasses)
	{
		pClasses->Release();
		pClasses = NULL;
	}
	if(pQualifiers)
	{
		pQualifiers->Release();
		pQualifiers = NULL;
	}
	VariantClear(&varGuid);
	VariantClear(&varVersion);
	return pClass;
}
Esempio n. 4
0
SCODE CreateClass( IWbemServices * pNamespace, IWbemClassObject ** pNewClass,
                   WCHAR * pwcClassName,
                   IWbemContext  *pCtx)
{

    SCODE sc;
    sc = pNamespace->GetObject(NULL, 0, pCtx, pNewClass, NULL);
    if(sc != S_OK)
        return sc;

    VARIANT v;

    // Set the class name.

    v.vt = VT_BSTR;
    v.bstrVal = SysAllocString(pwcClassName);
    if (!v.bstrVal)
        return WBEM_E_OUT_OF_MEMORY;
    sc = (*pNewClass)->Put(L"__class", 0, &v, 0);
    VariantClear(&v);


    // Set the key property value.

    v.vt = VT_NULL;
    sc = (*pNewClass)->Put(L"MyKey", 0, &v, CIM_STRING);

    // Set the number property value.

    sc = (*pNewClass)->Put(L"MyValue", 0, &v, CIM_SINT32);

    // Set the key qualifier

    IWbemQualifierSet* pQualSet = NULL;

    sc = (*pNewClass)->GetPropertyQualifierSet(L"MyKey", &pQualSet);
    if(pQualSet)
    {
        v.vt = VT_BOOL;
        v.boolVal = VARIANT_TRUE;
        sc = pQualSet->Put(L"Key", &v, 0);
        pQualSet->Release();
    }

    // Set the dynamic qualifier

    sc = (*pNewClass)->GetQualifierSet(&pQualSet);
    if(pQualSet)
    {
        v.vt = VT_BOOL;
        v.boolVal = VARIANT_TRUE;
        sc = pQualSet->Put(L"Dynamic", &v, 0);

        v.vt = VT_BSTR;
        v.bstrVal = SysAllocString(L"ClassProvSamp");
        if (v.bstrVal)
            sc = pQualSet->Put(L"Provider", &v, 0);
        else
            sc = WBEM_E_OUT_OF_MEMORY;
        VariantClear(&v);

        pQualSet->Release();
    }

    return sc;

}