You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1269 lines
33 KiB
1269 lines
33 KiB
// attachment.cpp: implementation of the Sce_PodData class.
|
|
//
|
|
// Copyright (c)1997-1999 Microsoft Corporation
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#include "precomp.h"
|
|
#include "attachment.h"
|
|
#include "persistmgr.h"
|
|
#include <io.h>
|
|
#include "requestobject.h"
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::CPodData
|
|
|
|
Functionality:
|
|
|
|
This is the constructor. Pass along the parameters to the base class
|
|
|
|
Virtual:
|
|
|
|
No (you know that, constructor won't be virtual!)
|
|
|
|
Arguments:
|
|
|
|
pKeyChain - Pointer to the ISceKeyChain COM interface which is prepared
|
|
by the caller who constructs this instance.
|
|
|
|
pNamespace - Pointer to WMI namespace of our provider (COM interface).
|
|
Passed along by the caller. Must not be NULL.
|
|
|
|
pCtx - Pointer to WMI context object (COM interface). Passed along
|
|
by the caller. It's up to WMI whether this interface pointer is NULL or not.
|
|
|
|
Return Value:
|
|
|
|
None as any constructor
|
|
|
|
Notes:
|
|
if you create any local members, think about initialize them here
|
|
|
|
*/
|
|
|
|
CPodData::CPodData (
|
|
IN ISceKeyChain * pKeyChain,
|
|
IN IWbemServices * pNamespace,
|
|
IN IWbemContext * pCtx
|
|
)
|
|
:
|
|
CGenericClass(pKeyChain, pNamespace, pCtx)
|
|
{
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::~CPodData
|
|
|
|
Functionality:
|
|
|
|
Destructor. Necessary as good C++ discipline since we have virtual functions.
|
|
|
|
Virtual:
|
|
|
|
Yes.
|
|
|
|
Arguments:
|
|
|
|
none as any destructor
|
|
|
|
Return Value:
|
|
|
|
None as any destructor
|
|
|
|
Notes:
|
|
if you create any local members, think about whether
|
|
there is any need for a non-trivial destructor
|
|
|
|
*/
|
|
|
|
CPodData::~CPodData()
|
|
{
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::CreateObject
|
|
|
|
Functionality:
|
|
|
|
Create WMI objects (Sce_PodData). Depending on parameter atAction,
|
|
this creation may mean:
|
|
(a) Get a single instance (atAction == ACTIONTYPE_GET)
|
|
(b) Get several instances satisfying some criteria (atAction == ACTIONTYPE_QUERY)
|
|
(c) Delete an instance (atAction == ACTIONTYPE_DELETE)
|
|
|
|
Virtual:
|
|
|
|
Yes.
|
|
|
|
Arguments:
|
|
|
|
pHandler - COM interface pointer for notifying WMI for creation result.
|
|
atAction - Get single instance ACTIONTYPE_GET
|
|
Get several instances ACTIONTYPE_QUERY
|
|
Delete a single instance ACTIONTYPE_DELETE
|
|
|
|
Return Value:
|
|
|
|
Success: it must return success code (use SUCCEEDED to test). It is
|
|
not guaranteed to return WBEM_NO_ERROR. The returned objects are indicated to WMI,
|
|
not directly passed back via parameters.
|
|
|
|
Failure: Various errors may occurs. Except WBEM_E_NOT_FOUND, any such error should indicate
|
|
the failure of getting the wanted instance. If WBEM_E_NOT_FOUND is returned in querying
|
|
situations, this may not be an error depending on caller's intention.
|
|
|
|
Notes:
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CPodData::CreateObject (
|
|
IN IWbemObjectSink * pHandler,
|
|
IN ACTIONTYPE atAction
|
|
)
|
|
{
|
|
//
|
|
// we know how to:
|
|
// Get single instance ACTIONTYPE_GET
|
|
// Delete a single instance ACTIONTYPE_DELETE
|
|
// Get several instances ACTIONTYPE_QUERY
|
|
//
|
|
|
|
if ( ACTIONTYPE_GET != atAction &&
|
|
ACTIONTYPE_DELETE != atAction &&
|
|
ACTIONTYPE_QUERY != atAction ) {
|
|
|
|
return WBEM_E_NOT_SUPPORTED;
|
|
}
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
//
|
|
// enumerate all properties
|
|
//
|
|
|
|
//
|
|
// We must have a store to get/delete an Sce_PodData object(s).
|
|
// Note: GetKeyPropertyValue will return WBEM_S_FALSE if the key is not recognized.
|
|
// That is why we check against it and return failure as long as it is not querying.
|
|
//
|
|
|
|
CComVariant varStorePath;
|
|
hr = m_srpKeyChain->GetKeyPropertyValue(pStorePath, &varStorePath);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
else if (hr == WBEM_S_FALSE)
|
|
{
|
|
return WBEM_E_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Pod ID is a key property. We must also have Pod ID, unless we are querying.
|
|
//
|
|
|
|
CComVariant varPodID;
|
|
hr = m_srpKeyChain->GetKeyPropertyValue(pPodID, &varPodID);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
else if (hr == WBEM_S_FALSE && (ACTIONTYPE_QUERY != atAction) )
|
|
{
|
|
return WBEM_E_NOT_FOUND;
|
|
}
|
|
|
|
CComVariant varPodSection;
|
|
hr = m_srpKeyChain->GetKeyPropertyValue(pPodSection, &varPodSection);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
else if (hr == WBEM_S_FALSE && (ACTIONTYPE_QUERY != atAction) )
|
|
{
|
|
return WBEM_E_NOT_FOUND;
|
|
}
|
|
|
|
CComVariant varKey;
|
|
hr = m_srpKeyChain->GetKeyPropertyValue(pKey, &varKey);
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
else if (hr == WBEM_S_FALSE && (ACTIONTYPE_QUERY != atAction) )
|
|
{
|
|
return WBEM_E_NOT_FOUND;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Prepare a store (for persistence) for this store path (file)
|
|
//
|
|
|
|
CSceStore SceStore;
|
|
hr = SceStore.SetPersistPath(varStorePath.bstrVal);
|
|
|
|
if ( SUCCEEDED(hr) ) {
|
|
|
|
//
|
|
// make sure the store (just a file) really exists. The raw path
|
|
// may contain env variables, so we need the expanded path
|
|
//
|
|
|
|
DWORD dwAttrib = GetFileAttributes(SceStore.GetExpandedPath());
|
|
|
|
if ( dwAttrib != -1 )
|
|
{
|
|
//
|
|
// the file exist
|
|
//
|
|
|
|
BOOL bPostFilter=TRUE;
|
|
DWORD dwCount = 0;
|
|
m_srpKeyChain->GetKeyPropertyCount(&dwCount);
|
|
|
|
if ( varKey.vt == VT_BSTR )
|
|
{
|
|
//
|
|
// doesn't matter if this comes from QUERY, GET, or DELETE
|
|
// do the same logic for QUERY and GET
|
|
//
|
|
|
|
if ( ACTIONTYPE_DELETE == atAction )
|
|
{
|
|
hr = DeleteInstance(&SceStore, varPodID.bstrVal, varPodSection.bstrVal, varKey.bstrVal );
|
|
}
|
|
else {
|
|
|
|
if ( ACTIONTYPE_QUERY == atAction && dwCount == 2 ) {
|
|
bPostFilter = FALSE;
|
|
}
|
|
hr = ConstructInstance(pHandler, &SceStore,
|
|
varStorePath.bstrVal,
|
|
(varPodID.vt == VT_BSTR) ? varPodID.bstrVal : NULL,
|
|
(varPodSection.vt == VT_BSTR) ? varPodSection.bstrVal : NULL,
|
|
(varKey.vt == VT_BSTR) ? varKey.bstrVal : NULL,
|
|
bPostFilter );
|
|
}
|
|
|
|
} else if ( ACTIONTYPE_QUERY == atAction )
|
|
{
|
|
//
|
|
// this is only valid for QUERY type
|
|
//
|
|
|
|
if ( dwCount == 1 ) {
|
|
bPostFilter = FALSE;
|
|
}
|
|
hr = ConstructQueryInstances(pHandler, &SceStore,
|
|
varStorePath.bstrVal,
|
|
(varPodID.vt == VT_BSTR) ? varPodID.bstrVal : NULL,
|
|
(varPodSection.vt == VT_BSTR) ? varPodSection.bstrVal : NULL,
|
|
bPostFilter
|
|
);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
hr = WBEM_E_NOT_FOUND;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::PutInst
|
|
|
|
Functionality:
|
|
|
|
Put an instance as instructed by WMI. Since this class implements Sce_PodData,
|
|
which is persistence oriented, this will cause the Sce_PodData object's property
|
|
information to be saved in our store.
|
|
|
|
Virtual:
|
|
|
|
Yes.
|
|
|
|
Arguments:
|
|
|
|
pInst - COM interface pointer to the WMI class (Sce_PodData) object.
|
|
|
|
pHandler - COM interface pointer for notifying WMI of any events.
|
|
|
|
pCtx - COM interface pointer. This interface is just something we pass around.
|
|
WMI may mandate it (not now) in the future. But we never construct
|
|
such an interface and so, we just pass around for various WMI API's
|
|
|
|
Return Value:
|
|
|
|
Success: it must return success code (use SUCCEEDED to test). It is
|
|
not guaranteed to return WBEM_NO_ERROR.
|
|
|
|
Failure: Various errors may occurs. Any such error should indicate the failure of persisting
|
|
the instance.
|
|
|
|
Notes:
|
|
Since GetProperty will return a success code (WBEM_S_RESET_TO_DEFAULT) when the
|
|
requested property is not present, don't simply use SUCCEEDED or FAILED macros
|
|
to test for the result of retrieving a property.
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CPodData::PutInst (
|
|
IN IWbemClassObject * pInst,
|
|
IN IWbemObjectSink * pHandler,
|
|
IN IWbemContext * pCtx
|
|
)
|
|
{
|
|
//
|
|
// this property manager will help us gain access to the properties of the WMI object
|
|
//
|
|
|
|
CScePropertyMgr ScePropMgr;
|
|
|
|
//
|
|
// This property manager is for this object (pInst) only!
|
|
// Will always succeed
|
|
//
|
|
|
|
ScePropMgr.Attach(pInst);
|
|
|
|
//
|
|
// The store is used to persist the information. Since
|
|
// we have a whole bunch of goto's, we are forced to define
|
|
// the store here.
|
|
//
|
|
|
|
CSceStore SceStore;
|
|
|
|
//
|
|
// we manage the memory of this variable. need to free it
|
|
//
|
|
|
|
LPWSTR pszSectionName = NULL;
|
|
|
|
// the memory for these bstrs are automatically managed by the CComBSTR class
|
|
CComBSTR bstrPodID;
|
|
CComBSTR bstrPodSuffix;
|
|
CComBSTR bstrKey;
|
|
CComBSTR bstrValue;
|
|
|
|
//
|
|
// we consider each property of the Sce_PodData non-optional.
|
|
// For the entire duration of this save action, if missing property
|
|
// will thus cause us to quit
|
|
//
|
|
|
|
HRESULT hr = ScePropMgr.GetProperty(pPodID, &bstrPodID);
|
|
if (FAILED(hr) || hr == WBEM_S_RESET_TO_DEFAULT)
|
|
{
|
|
goto CleanUp;
|
|
}
|
|
|
|
hr = ScePropMgr.GetProperty(pPodSection, &bstrPodSuffix);
|
|
if (FAILED(hr) || hr == WBEM_S_RESET_TO_DEFAULT)
|
|
{
|
|
goto CleanUp;
|
|
}
|
|
|
|
hr = ValidatePodID(bstrPodID);
|
|
if (FAILED(hr))
|
|
{
|
|
goto CleanUp;
|
|
}
|
|
|
|
hr = ScePropMgr.GetProperty(pKey, &bstrKey);
|
|
if (FAILED(hr) || hr == WBEM_S_RESET_TO_DEFAULT)
|
|
{
|
|
goto CleanUp;
|
|
}
|
|
|
|
hr = ScePropMgr.GetProperty(pValue, &bstrValue);
|
|
if (FAILED(hr) || hr == WBEM_S_RESET_TO_DEFAULT)
|
|
{
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// now build the section name
|
|
//
|
|
|
|
pszSectionName = new WCHAR[wcslen(bstrPodID) + wcslen(bstrPodSuffix) + 2];
|
|
if ( NULL == pszSectionName )
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// this won't overrun the buffer. See the size allocated above
|
|
//
|
|
|
|
wcscpy(pszSectionName, bstrPodID);
|
|
wcscat(pszSectionName, L"_");
|
|
wcscat(pszSectionName, bstrPodSuffix);
|
|
|
|
//
|
|
// Attach the WMI object instance to the store and let the store know that
|
|
// it's store is given by the pStorePath property of the instance.
|
|
//
|
|
|
|
hr = SceStore.SetPersistProperties(pInst, pStorePath);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SceStore.SavePropertyToStore(pszSectionName, bstrKey, bstrValue);
|
|
}
|
|
|
|
CleanUp:
|
|
|
|
//
|
|
// We consider the object invalid if there is any missing property.
|
|
//
|
|
|
|
if (hr == WBEM_S_RESET_TO_DEFAULT)
|
|
{
|
|
hr = WBEM_E_INVALID_OBJECT;
|
|
}
|
|
|
|
delete [] pszSectionName;
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::ConstructInstance
|
|
|
|
Functionality:
|
|
|
|
This is private function to create an instance of Sce_PodData.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pHandler - COM interface pointer for notifying WMI of any events.
|
|
|
|
pSceStore - Pointer to our store. It must have been appropriately set up.
|
|
|
|
wszLogStorePath - store path, a key property of Sce_PodData class.
|
|
|
|
wszPodID - a corresponding key property of Sce_PodData class.
|
|
|
|
wszSection - another corresponding property of the Sce_PodData class.
|
|
|
|
wszKey - another corresponding property of the Sce_PodData class.
|
|
|
|
bPostFilter - Controls how WMI will be informed with pHandler->SetStatus.
|
|
|
|
Return Value:
|
|
|
|
Success: it must return success code (use SUCCEEDED to test). It is
|
|
not guaranteed to return WBEM_NO_ERROR.
|
|
|
|
Failure: Various errors may occurs. Any such error should indicate the creating the instance.
|
|
|
|
Notes:
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CPodData::ConstructInstance (
|
|
IN IWbemObjectSink * pHandler,
|
|
IN CSceStore * pSceStore,
|
|
IN LPCWSTR wszLogStorePath,
|
|
IN LPCWSTR wszPodID,
|
|
IN LPCWSTR wszSection,
|
|
IN LPCWSTR wszKey,
|
|
IN BOOL bPostFilter
|
|
)
|
|
{
|
|
|
|
HRESULT hr=WBEM_S_NO_ERROR;
|
|
SCESTATUS rc;
|
|
|
|
hr = ValidatePodID(wszPodID);
|
|
if ( FAILED(hr) )
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// we need to construct a more complicated section name based on the wszPodID and wszSection.
|
|
//
|
|
|
|
PWSTR wszSectionName = new WCHAR[wcslen(wszPodID) + wcslen(wszSection) + 2];
|
|
if ( !wszSectionName )
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//
|
|
// this won't overrun the buffer. See the size allocated above
|
|
//
|
|
|
|
wcscpy(wszSectionName, wszPodID);
|
|
wcscat(wszSectionName, L"_");
|
|
wcscat(wszSectionName, wszSection);
|
|
|
|
//
|
|
// this will hold the information read by Sce
|
|
//
|
|
|
|
PSCESVC_CONFIGURATION_INFO pPodInfo=NULL;
|
|
|
|
//
|
|
// wszValue's memory is very strangely obtained. Be aware.
|
|
// (1) When the information is from INF file, the wszValue points
|
|
// to a memory already managed by pPodInfo. Hence, its release
|
|
// is done by the release of pPodInfo.
|
|
// (2) When the information is from a database, then we need to
|
|
// release the memory pointed to by wszValue.
|
|
//
|
|
|
|
PWSTR wszValue=NULL;
|
|
DWORD dwValueLen=0;
|
|
|
|
if ( pSceStore->GetStoreType() == SCE_INF_FORMAT )
|
|
{
|
|
//
|
|
// ask SCE to read the information
|
|
//
|
|
|
|
rc = SceSvcGetInformationTemplate(pSceStore->GetExpandedPath(),
|
|
wszSectionName,
|
|
wszKey,
|
|
&pPodInfo
|
|
);
|
|
|
|
//
|
|
// SCE returned errors needs to be translated to HRESULT.
|
|
// In case this is not an error, hr will be assigned to WBEM_NO_ERROR
|
|
//
|
|
|
|
hr = ProvDosErrorToWbemError(ProvSceStatusToDosError(rc));
|
|
|
|
if (rc == SCESTATUS_SUCCESS && pPodInfo && pPodInfo->Lines ) {
|
|
wszValue = pPodInfo->Lines[0].Value;
|
|
dwValueLen = pPodInfo->Lines[0].ValueLen;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// get information from the database
|
|
//
|
|
|
|
PVOID hProfile=NULL;
|
|
|
|
rc = SceOpenProfile(pSceStore->GetExpandedPath(), SCE_JET_FORMAT, &hProfile);
|
|
|
|
if ( SCESTATUS_SUCCESS == rc ) {
|
|
rc = SceGetDatabaseSetting(
|
|
hProfile,
|
|
SCE_ENGINE_SMP,
|
|
(PWSTR)wszSectionName,
|
|
(PWSTR)wszKey,
|
|
&wszValue,
|
|
&dwValueLen
|
|
);
|
|
|
|
SceCloseProfile(&hProfile);
|
|
}
|
|
|
|
//
|
|
// SCE returned errors needs to be translated to HRESULT.
|
|
// In case this is not an error, hr will be assigned to WBEM_NO_ERROR
|
|
//
|
|
|
|
hr = ProvDosErrorToWbemError(ProvSceStatusToDosError(rc));
|
|
}
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
|
|
CComBSTR bstrLogOut;
|
|
hr = MakeSingleBackSlashPath(wszLogStorePath, L'\\', &bstrLogOut);
|
|
if ( FAILED(hr) )
|
|
{
|
|
goto CleanUp;
|
|
}
|
|
|
|
hr = PutPodDataInstance(pHandler,
|
|
bstrLogOut,
|
|
wszPodID,
|
|
wszSection,
|
|
wszKey,
|
|
wszValue,
|
|
bPostFilter
|
|
);
|
|
}
|
|
|
|
CleanUp:
|
|
|
|
//
|
|
// only Sce knows how to free a PSCESVC_CONFIGURATION_INFO
|
|
//
|
|
|
|
if ( pPodInfo )
|
|
{
|
|
SceSvcFree(pPodInfo);
|
|
}
|
|
|
|
delete [] wszSectionName;
|
|
|
|
if ( pSceStore->GetStoreType() != SCE_INF_FORMAT && wszValue )
|
|
{
|
|
::LocalFree(wszValue);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::DeleteInstance
|
|
|
|
Functionality:
|
|
|
|
remove an instance of Sce_PodData from the specified store.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pSceStore - Pointer to our store. It must have been appropriately set up.
|
|
|
|
wszPodID - a corresponding key property of Sce_PodData class.
|
|
|
|
wszSection - another corresponding property of the Sce_PodData class.
|
|
|
|
wszKey - another corresponding property of the Sce_PodData class.
|
|
|
|
Return Value:
|
|
|
|
Success: it must return success code (use SUCCEEDED to test). It is
|
|
not guaranteed to return WBEM_NO_ERROR.
|
|
|
|
Failure: Various errors may occurs. Any such error should indicate the operation is not carried out
|
|
|
|
Notes:
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CPodData::DeleteInstance (
|
|
IN CSceStore * pSceStore,
|
|
IN LPCWSTR wszPodID,
|
|
IN LPCWSTR wszSection,
|
|
IN LPCWSTR wszKey
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
hr = ValidatePodID(wszPodID);
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Our store needs a section name. But for Sce_PodData, the store section name
|
|
// is composed by the supplied section name and the PodID.
|
|
// Don't forget to free the memory!
|
|
//
|
|
|
|
PWSTR wszSectionName = new WCHAR[wcslen(wszPodID) + wcslen(wszSection) + 2];
|
|
if ( !wszSectionName )
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//
|
|
// this won't overrun the buffer. See the size allocated above
|
|
// Real composition happens here: the store's section name is wszPodID_wszSection
|
|
//
|
|
|
|
wcscpy(wszSectionName, wszPodID);
|
|
wcscat(wszSectionName, L"_");
|
|
wcscat(wszSectionName, wszSection);
|
|
|
|
hr = pSceStore->DeletePropertyFromStore(wszSectionName, wszKey);
|
|
|
|
delete [] wszSectionName;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::ConstructQueryInstances
|
|
|
|
Functionality:
|
|
|
|
Querying instances of Sce_PodData whose key properties meet the specified parameters.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pHandler - COM interface pointer used to notify WMI when instances are created.
|
|
|
|
pSceStore - Pointer to our store. It must have been appropriately set up.
|
|
|
|
wszLogStorePath - Log's store path.
|
|
|
|
wszPodID - may be NULL.
|
|
|
|
wszSection - may be NULL.
|
|
|
|
bPostFilter -
|
|
|
|
Return Value:
|
|
|
|
Success: it must return success code (use SUCCEEDED to test). It is
|
|
not guaranteed to return WBEM_NO_ERROR.
|
|
|
|
Failure: Various errors may occurs. Any such error should indicate the operation is not carried out
|
|
|
|
Notes:
|
|
|
|
*/
|
|
|
|
HRESULT
|
|
CPodData::ConstructQueryInstances (
|
|
IWbemObjectSink * pHandler,
|
|
CSceStore * pSceStore,
|
|
LPCWSTR wszLogStorePath,
|
|
LPCWSTR wszPodID,
|
|
LPCWSTR wszSection,
|
|
BOOL bPostFilter
|
|
)
|
|
{
|
|
//
|
|
// make sure that we have a valid store
|
|
//
|
|
|
|
if ( pSceStore == NULL ||
|
|
pSceStore->GetStoreType() < SCE_INF_FORMAT ||
|
|
pSceStore->GetStoreType() > SCE_JET_ANALYSIS_REQUIRED )
|
|
{
|
|
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// we can't do anything if we don't have pszPodID or wszSection
|
|
//
|
|
|
|
if (wszPodID == NULL || wszSection == NULL)
|
|
{
|
|
return WBEM_E_NOT_SUPPORTED;
|
|
}
|
|
|
|
HRESULT hr=WBEM_S_NO_ERROR;
|
|
SCESTATUS rc;
|
|
|
|
PSCESVC_CONFIGURATION_INFO pPodInfo=NULL;
|
|
LPWSTR wszSectionName = NULL;
|
|
PVOID hProfile=NULL;
|
|
CComBSTR bstrLogOut;
|
|
LPWSTR pszNewValue=NULL;
|
|
|
|
try {
|
|
|
|
hr = ValidatePodID(wszPodID);
|
|
if ( FAILED(hr) )
|
|
{
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// build section name for the POD
|
|
//
|
|
|
|
wszSectionName = new WCHAR[wcslen(wszPodID) + wcslen(wszSection) + 2];
|
|
|
|
if ( !wszSectionName )
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//
|
|
// this won't overrun the buffer. See the size allocated above
|
|
//
|
|
|
|
wcscpy(wszSectionName, wszPodID);
|
|
wcscat(wszSectionName, L"_");
|
|
wcscat(wszSectionName, wszSection);
|
|
|
|
DWORD i;
|
|
|
|
hr = MakeSingleBackSlashPath(wszLogStorePath, L'\\', &bstrLogOut);
|
|
|
|
if ( FAILED(hr) )
|
|
{
|
|
goto CleanUp;
|
|
}
|
|
|
|
if ( pSceStore->GetStoreType() == SCE_INF_FORMAT ) {
|
|
|
|
//
|
|
// INF template, query info
|
|
//
|
|
|
|
rc = SceSvcGetInformationTemplate(pSceStore->GetExpandedPath(),
|
|
wszSectionName,
|
|
NULL,
|
|
&pPodInfo
|
|
);
|
|
|
|
//
|
|
// SCE returned errors needs to be translated to HRESULT.
|
|
// In case this is not an error, hr will be assigned to WBEM_NO_ERROR
|
|
//
|
|
|
|
hr = ProvDosErrorToWbemError(ProvSceStatusToDosError(rc));
|
|
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
if ( !pPodInfo || pPodInfo->Count == 0 || pPodInfo->Lines == NULL )
|
|
{
|
|
hr = WBEM_E_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
if ( SUCCEEDED(hr) ) {
|
|
for ( i=0; SUCCEEDED(hr) && i<pPodInfo->Count; i++ ) {
|
|
|
|
//
|
|
// create instance for each one
|
|
//
|
|
// since this PSCESVC_CONFIGURATION_INFO is from INF template, pPodInfo->Lines[i].Value
|
|
// is guaranteed to be 0 terminated. See comments of next block about using pPodInfo->Lines[i].Value.
|
|
//
|
|
|
|
hr = PutPodDataInstance(pHandler,
|
|
bstrLogOut,
|
|
wszPodID,
|
|
wszSection,
|
|
pPodInfo->Lines[i].Key,
|
|
pPodInfo->Lines[i].Value,
|
|
bPostFilter
|
|
);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// get information from the database
|
|
//
|
|
|
|
rc = SceOpenProfile(pSceStore->GetExpandedPath(), SCE_JET_FORMAT, &hProfile);
|
|
|
|
if ( SCESTATUS_SUCCESS == rc ) {
|
|
|
|
SCEP_HANDLE scepHandle;
|
|
scepHandle.hProfile = hProfile;
|
|
scepHandle.SectionName = wszSectionName;
|
|
|
|
SCE_ENUMERATION_CONTEXT EnumHandle=0;
|
|
DWORD CountReturned;
|
|
|
|
do {
|
|
|
|
//
|
|
// enumerate the info
|
|
//
|
|
|
|
CountReturned = 0;
|
|
|
|
rc = SceSvcQueryInfo((SCE_HANDLE)&scepHandle,
|
|
SceSvcConfigurationInfo,
|
|
NULL,
|
|
FALSE,
|
|
(PVOID *)&pPodInfo,
|
|
&EnumHandle
|
|
);
|
|
//
|
|
// SCE returned errors needs to be translated to HRESULT.
|
|
// In case this is not an error, hr will be assigned to WBEM_NO_ERROR
|
|
//
|
|
|
|
hr = ProvDosErrorToWbemError(ProvSceStatusToDosError(rc));
|
|
|
|
if ( SUCCEEDED(hr) ) {
|
|
if ( !pPodInfo || pPodInfo->Count == 0 || pPodInfo->Lines == NULL )
|
|
{
|
|
hr = WBEM_E_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
if ( SUCCEEDED(hr) ) {
|
|
|
|
//
|
|
// got something
|
|
//
|
|
|
|
CountReturned = pPodInfo->Count;
|
|
|
|
for ( i=0; SUCCEEDED(hr) && i<pPodInfo->Count; i++ ) {
|
|
|
|
//
|
|
// create instance for each one
|
|
//
|
|
// pPodInfo->Lines[i].Value may not be 0 terminated
|
|
// pPodInfo->Lines[i].ValueLen is the BYTE size of the buffer pPodInfo->Lines[i].Value
|
|
//
|
|
|
|
LPWSTR pNewVal = new WCHAR[pPodInfo->Lines[i].ValueLen/2 + 1];
|
|
|
|
if (pNewVal != NULL)
|
|
{
|
|
memcpy(pNewVal, pPodInfo->Lines[i].Value, pPodInfo->Lines[i].ValueLen);
|
|
pNewVal[pPodInfo->Lines[i].ValueLen/2] = L'\0';
|
|
|
|
hr = PutPodDataInstance(pHandler,
|
|
bstrLogOut,
|
|
wszPodID,
|
|
wszSection,
|
|
pPodInfo->Lines[i].Key,
|
|
pNewVal,
|
|
bPostFilter
|
|
);
|
|
delete [] pNewVal;
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pPodInfo ) {
|
|
SceSvcFree(pPodInfo);
|
|
pPodInfo = NULL;
|
|
}
|
|
|
|
} while ( SUCCEEDED(hr) && CountReturned >= SCESVC_ENUMERATION_MAX );
|
|
|
|
SceCloseProfile(&hProfile);
|
|
|
|
} else {
|
|
|
|
//
|
|
// SCE returned errors needs to be translated to HRESULT.
|
|
// In case this is not an error, hr will be assigned to WBEM_NO_ERROR
|
|
//
|
|
|
|
hr = ProvDosErrorToWbemError(ProvSceStatusToDosError(rc));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch(...)
|
|
{
|
|
}
|
|
|
|
CleanUp:
|
|
|
|
if (hProfile)
|
|
{
|
|
SceCloseProfile(&hProfile);
|
|
}
|
|
|
|
if ( pPodInfo )
|
|
{
|
|
SceSvcFree(pPodInfo);
|
|
}
|
|
|
|
delete [] wszSectionName;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::ValidatePodID
|
|
|
|
Functionality:
|
|
|
|
validate the PodID with registered Pods.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
wszPodID - string representing the Pod ID to be verified.
|
|
|
|
Return Value:
|
|
|
|
Success: it must return success code (use SUCCEEDED to test). It is
|
|
not guaranteed to return WBEM_NO_ERROR.
|
|
|
|
Failure: Various errors may occurs:
|
|
(1) WBEM_E_NOT_FOUND if we successfully carry out the validation task and confirmed
|
|
that we don't recognize the pod ID.
|
|
(2) Other errors means that we can't carry out the validation at all. This doesn't mean
|
|
that the Pod ID is invalid. It's just that the means to verify is not available.
|
|
|
|
Notes:
|
|
*/
|
|
|
|
HRESULT
|
|
CPodData::ValidatePodID (
|
|
LPCWSTR wszPodID
|
|
)
|
|
{
|
|
//
|
|
// no namespace means no access to WMI
|
|
//
|
|
|
|
if ( m_srpNamespace == NULL )
|
|
{
|
|
return WBEM_E_CRITICAL_ERROR;
|
|
}
|
|
|
|
if ( wszPodID == NULL )
|
|
{
|
|
return WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// we will create a "select" query and ask WMI to return the pods
|
|
//
|
|
|
|
DWORD Len = wcslen(wszPodID);
|
|
|
|
//
|
|
// pQuery has an open quote that needs to be matched (and closed)
|
|
//
|
|
|
|
LPCWSTR pQuery = L"SELECT * FROM Sce_Pod WHERE PodID=\"";
|
|
|
|
//
|
|
// we need two extra WCHAR: one for the encloding quote, and other for the 0 terminator
|
|
//
|
|
|
|
LPWSTR pszQuery= new WCHAR[Len + wcslen(pQuery) + 2];
|
|
if ( pszQuery == NULL )
|
|
{
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
//
|
|
// no danger of overrun the buffer. See the size allocated above
|
|
// Compose the query by appending the pod ID and the ending quote
|
|
//
|
|
|
|
wcscpy(pszQuery, pQuery);
|
|
wcscat(pszQuery, wszPodID);
|
|
wcscat(pszQuery, L"\"");
|
|
|
|
//
|
|
// Ask WMI to return all Pods. ExecQuery returns a enumerator.
|
|
//
|
|
|
|
CComPtr<IEnumWbemClassObject> srpEnum;
|
|
|
|
HRESULT hr = m_srpNamespace->ExecQuery(L"WQL",
|
|
pszQuery,
|
|
WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
|
|
NULL,
|
|
&srpEnum);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// should only get one instance because we are given its key (PodID)
|
|
//
|
|
|
|
CComPtr<IWbemClassObject> srpObj;
|
|
ULONG n = 0;
|
|
|
|
//
|
|
// srpEnum->Next will return WBEM_NO_ERROR together with the WMI object
|
|
// and a count (n) > 0. We only ask for 1 instance.
|
|
//
|
|
|
|
hr = srpEnum->Next(WBEM_INFINITE, 1, &srpObj, &n);
|
|
|
|
if ( hr == WBEM_S_FALSE )
|
|
{
|
|
hr = WBEM_E_NOT_FOUND; // not find any
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (n > 0)
|
|
{
|
|
//
|
|
// find the instance
|
|
//
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_NOT_FOUND;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] pszQuery;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
Routine Description:
|
|
|
|
Name:
|
|
|
|
CPodData::PutPodDataInstance
|
|
|
|
Functionality:
|
|
|
|
With all the properties of a Sce_PodData, this function just creates a new
|
|
instance and populate the properties and then hand it back to WMI.
|
|
|
|
Virtual:
|
|
|
|
No.
|
|
|
|
Arguments:
|
|
|
|
pHandler - COM interface pointer for notifying WMI of any events.
|
|
|
|
wszStoreName - store path, a key property of Sce_PodData class.
|
|
|
|
wszPodID - a corresponding key property of Sce_PodData class.
|
|
|
|
wszSection - another corresponding property of the Sce_PodData class.
|
|
|
|
wszKey - another corresponding property of the Sce_PodData class.
|
|
|
|
wszValue - The payload of the Sce_PodData class, where the information really is.
|
|
|
|
bPostFilter - Controls how WMI will be informed with pHandler->SetStatus.
|
|
|
|
Return Value:
|
|
|
|
Success: it must return success code (use SUCCEEDED to test). It is
|
|
not guaranteed to return WBEM_NO_ERROR.
|
|
|
|
Failure: Various errors may occurs. Any error indicates the failure to create the instance.
|
|
|
|
Notes:
|
|
*/
|
|
|
|
HRESULT
|
|
CPodData::PutPodDataInstance (
|
|
IN IWbemObjectSink * pHandler,
|
|
IN LPCWSTR wszStoreName,
|
|
IN LPCWSTR wszPodID,
|
|
IN LPCWSTR wszSection,
|
|
IN LPCWSTR wszKey,
|
|
IN LPCWSTR wszValue,
|
|
IN BOOL bPostFilter
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
|
|
//
|
|
// need a blank instance that can be used to fill in properties
|
|
//
|
|
|
|
CComPtr<IWbemClassObject> srpObj;
|
|
if (SUCCEEDED(hr = SpawnAnInstance(&srpObj)))
|
|
{
|
|
CScePropertyMgr ScePropMgr;
|
|
ScePropMgr.Attach(srpObj);
|
|
|
|
//
|
|
// the property fillup is repeatitive and boring. here we use two arrays
|
|
// (pszProperties is the property names, and pszValues the the values of
|
|
// the corresponding properties)
|
|
//
|
|
|
|
LPCWSTR pszProperties[] = {pStorePath, pPodID, pPodSection, pKey, pValue};
|
|
LPCWSTR pszValues[] = {wszStoreName, wszPodID, wszSection, wszKey, wszValue};
|
|
|
|
//
|
|
// SCEPROV_SIZEOF_ARRAY is a macro that returns the array's size
|
|
//
|
|
|
|
for (int i = 0; i < SCEPROV_SIZEOF_ARRAY(pszProperties); i++)
|
|
{
|
|
if (FAILED(hr = ScePropMgr.PutProperty(pszProperties[i], pszValues[i])))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
//
|
|
// do the necessary gestures to WMI.
|
|
// the use of WBEM_STATUS_REQUIREMENTS in SetStatus is not documented by WMI
|
|
// at this point. Consult WMI team for detail if you suspect problems with
|
|
// the use of WBEM_STATUS_REQUIREMENTS
|
|
//
|
|
|
|
hr = pHandler->SetStatus(WBEM_STATUS_REQUIREMENTS, (bPostFilter ? S_OK : S_FALSE), NULL, NULL);
|
|
|
|
//
|
|
// give the new instance to WMI
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pHandler->Indicate(1, &srpObj);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|