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.
2576 lines
71 KiB
2576 lines
71 KiB
//----------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 2000.
|
|
//
|
|
// File: cumiobj.cxx
|
|
//
|
|
// Contents: Contains the implementation of IUmiObject. The methods are
|
|
// encapsulated in one object. This object holds a pointer to
|
|
// the inner unknown of the corresponding WinNT object.
|
|
// The methods of IUmiContainer are also implemented on this
|
|
// same object, but will only be used if the underlying WinNT
|
|
// object is a container.
|
|
//
|
|
// History: 03-06-00 SivaramR Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "winnt.hxx"
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: CUmiObject
|
|
//
|
|
// Synopsis: Constructor. Initializes member variable.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CUmiObject::CUmiObject(void)
|
|
{
|
|
m_pIntfProps = NULL;
|
|
m_pObjProps = NULL;
|
|
m_pUnkInner = NULL;
|
|
m_pIADs = NULL;
|
|
m_pIADsContainer = NULL;
|
|
m_ulErrorStatus = 0;
|
|
m_pCoreObj = NULL;
|
|
m_pExtMgr = NULL;
|
|
m_fOuterUnkSet = FALSE;
|
|
m_pPropCache = NULL;
|
|
m_fRefreshDone = FALSE;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: ~CUmiObject
|
|
//
|
|
// Synopsis: Destructor. Frees member variables.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CUmiObject::~CUmiObject(void)
|
|
{
|
|
if(m_pIntfProps != NULL)
|
|
m_pIntfProps->Release();
|
|
|
|
if(m_pObjProps != NULL)
|
|
delete m_pObjProps;
|
|
|
|
if(m_pUnkInner != NULL)
|
|
m_pUnkInner->Release();
|
|
|
|
//
|
|
// m_pIADs and m_pIADsContainer may now delegate to an outer unknown if
|
|
// if the ADSI object has been aggregated in GetObjectByCLSID
|
|
// subsequent to creation. Hence, we should not call Release() on either
|
|
// of these pointers. Instead, call Release() on m_pUnkInner since this
|
|
// is guaranteed to be a pointer to the non-delegating IUnknown.
|
|
//
|
|
if(m_pIADsContainer != NULL)
|
|
m_pUnkInner->Release();
|
|
|
|
if(m_pIADs != NULL)
|
|
m_pUnkInner->Release();
|
|
|
|
if(m_pPropCache != NULL)
|
|
delete m_pPropCache;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: FInit
|
|
//
|
|
// Synopsis: Initializes UMI object.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Credentials Credentials stored in the underlying WinNT object
|
|
// pSchema Pointer to schema for this object
|
|
// dwSchemaSize Size of schema array
|
|
// pPropCache Pointer to property cache for this object
|
|
// pUnkInner Pointer to inner unknown of underlying WinNT object
|
|
// pExtMgr Pointer to extension manager of underlying WinNT object
|
|
// pCoreObj Pointer to the core object of underlying WinNT object
|
|
// pClassInfo Pointer to class information if this object is a class object.
|
|
// NULL otherwise.
|
|
//
|
|
// Returns: S_OK on success. Error code otherwise.
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::FInit(
|
|
CWinNTCredentials& Credentials,
|
|
PPROPERTYINFO pSchema,
|
|
DWORD dwSchemaSize,
|
|
CPropertyCache *pPropertyCache,
|
|
IUnknown *pUnkInner,
|
|
CADsExtMgr *pExtMgr,
|
|
CCoreADsObject *pCoreObj,
|
|
CLASSINFO *pClassInfo
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CUmiPropList *pIntfProps = NULL;
|
|
|
|
ADsAssert(pCoreObj != NULL); // extension manager may be NULL for some
|
|
// WinNT objects
|
|
|
|
if(pPropertyCache != NULL) {
|
|
// some WinNT objects don't have a property cache associated with them.
|
|
// Namespace and schema objects are examples. For these, we might
|
|
// create a proeprty cache in the 'else' clause below. Otherwise, we
|
|
// return UMI_E_NOTIMPL from IUmiPropList methods since m_pObjProps will be
|
|
// NULL for these objects.
|
|
ADsAssert( (pSchema != NULL) && (dwSchemaSize > 0) &&
|
|
(pUnkInner != NULL) );
|
|
|
|
// Initialize property list for object properties
|
|
m_pObjProps = new CUmiPropList(pSchema, dwSchemaSize);
|
|
if(NULL == m_pObjProps)
|
|
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
|
|
|
|
hr = m_pObjProps->FInit(pPropertyCache, NULL);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
else if(pSchema != NULL) {
|
|
// Property, class, schema and syntax objects do not have a cache
|
|
// associated with them. But, they support a number of properties through
|
|
// IDispatch. We want to expose these through UMI. So create a property
|
|
// cache and populate it with these read-only properties. Thus,
|
|
// m_pObjProps will be NULL only for namespace objects.
|
|
|
|
ADsAssert( (pUnkInner != NULL) && (dwSchemaSize > 0) );
|
|
|
|
hr = CreateObjectProperties(
|
|
pSchema,
|
|
dwSchemaSize,
|
|
pUnkInner,
|
|
pCoreObj
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
// Initialize property list for interface properties
|
|
pIntfProps = new CUmiPropList(ObjClass, g_dwObjClassSize);
|
|
if(NULL == pIntfProps)
|
|
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
|
|
|
|
hr = pIntfProps->FInit(NULL, g_UmiObjUnImplProps);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pIntfProps->QueryInterface(
|
|
IID_IUmiPropList,
|
|
(void **) &m_pIntfProps
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// DECLARE_STD_REFCOUNTING initializes the refcount to 1. Call Release()
|
|
// on the created object, so that releasing the interface pointer will
|
|
// free the object.
|
|
pIntfProps->Release();
|
|
|
|
m_pUnkInner = pUnkInner;
|
|
|
|
// Get pointers to IADs and IADsContainer interfaces on WinNT object
|
|
hr = m_pUnkInner->QueryInterface(
|
|
IID_IADsContainer,
|
|
(void **) &m_pIADsContainer
|
|
);
|
|
|
|
if(FAILED(hr))
|
|
m_pIADsContainer = NULL;
|
|
|
|
hr = m_pUnkInner->QueryInterface(
|
|
IID_IADs,
|
|
(void **) &m_pIADs
|
|
);
|
|
|
|
if(FAILED(hr))
|
|
m_pIADs = NULL;
|
|
else {
|
|
hr = pIntfProps->SetStandardProperties(m_pIADs, pCoreObj);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
pIntfProps->SetClassInfo(pClassInfo);
|
|
|
|
// set the property count in the interface property cache
|
|
hr = pIntfProps->SetPropertyCount(dwSchemaSize);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
m_pExtMgr = pExtMgr;
|
|
m_pCoreObj = pCoreObj;
|
|
m_pCreds = &Credentials;
|
|
|
|
RRETURN(S_OK);
|
|
|
|
error:
|
|
|
|
if(m_pObjProps != NULL)
|
|
delete m_pObjProps;
|
|
|
|
if(m_pIntfProps != NULL)
|
|
m_pIntfProps->Release();
|
|
else if(pIntfProps != NULL)
|
|
delete pIntfProps;
|
|
|
|
if(m_pIADsContainer != NULL)
|
|
m_pIADsContainer->Release();
|
|
|
|
if(m_pIADs != NULL)
|
|
m_pIADs->Release();
|
|
|
|
// make sure destructor doesn't free these again
|
|
m_pObjProps = NULL;
|
|
m_pIntfProps = NULL;
|
|
m_pIADsContainer = NULL;
|
|
m_pIADs = NULL;
|
|
m_pUnkInner = NULL;
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: CreateObjectProperties
|
|
//
|
|
// Synopsis: Creates a property cache and populates it with the properties
|
|
// supported on the WinNT object's IDispatch interface. This is
|
|
// used to expose properties on property, class and syntax objects
|
|
// through UMI.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pSchema Pointer to schema for this object
|
|
// dwSchemaSize Size of schema array
|
|
// pUnkInner Pointer to inner unknown of underlying WinNT object
|
|
// pCoreObj Pointer to the core object of the WinNT object
|
|
//
|
|
// Returns: S_OK on success. Error code otherwise.
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::CreateObjectProperties(
|
|
PPROPERTYINFO pSchema,
|
|
DWORD dwSchemaSize,
|
|
IUnknown *pUnkInner,
|
|
CCoreADsObject *pCoreObj
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch *pDispatch = NULL;
|
|
DWORD dwIndex = 0;
|
|
DISPID DispId;
|
|
DISPPARAMS DispParams = {NULL, NULL, 0, 0};
|
|
VARIANT var;
|
|
CPropertyCache *pPropCache = NULL;
|
|
|
|
ADsAssert( (pSchema != NULL) && (dwSchemaSize > 0) &&
|
|
(pUnkInner != NULL) && (pCoreObj != NULL) );
|
|
|
|
hr = CPropertyCache::createpropertycache(
|
|
pSchema,
|
|
dwSchemaSize,
|
|
pCoreObj,
|
|
&pPropCache);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUnkInner->QueryInterface(
|
|
IID_IDispatch,
|
|
(void **) &pDispatch
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
for(dwIndex = 0; dwIndex < dwSchemaSize; dwIndex++) {
|
|
hr = pDispatch->GetIDsOfNames(
|
|
IID_NULL,
|
|
&pSchema[dwIndex].szPropertyName,
|
|
1,
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
&DispId
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pDispatch->Invoke(
|
|
DispId,
|
|
IID_NULL,
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
DISPATCH_PROPERTYGET,
|
|
&DispParams,
|
|
&var,
|
|
NULL,
|
|
NULL
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = GenericPutPropertyManager(
|
|
pPropCache,
|
|
pSchema,
|
|
dwSchemaSize,
|
|
pSchema[dwIndex].szPropertyName,
|
|
var,
|
|
FALSE
|
|
);
|
|
|
|
VariantClear(&var);
|
|
|
|
// If there is a multivalued ADSI interface property that has no values
|
|
// (such as MandatoryProperties/Containment on a schema object), the
|
|
// call to Invoke above returns a variant which has a safearray with
|
|
// 0 elements in it. The call to GenericPutPropertyManager will fail
|
|
// with E_ADS_BAD_PARAMETER in this case. In this case, don't store
|
|
// anything in the property cache for this property. Trying to fetch
|
|
// it later will return UMI_E_NOT_FOUND.
|
|
|
|
if(hr != E_ADS_BAD_PARAMETER)
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
// Mark all properties as "not modified", since the client really hasn't
|
|
// updated the cache, though we have.
|
|
pPropCache->ClearModifiedFlags();
|
|
|
|
// Initialize property list for object properties
|
|
m_pObjProps = new CUmiPropList(pSchema, dwSchemaSize);
|
|
if(NULL == m_pObjProps)
|
|
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
|
|
|
|
hr = m_pObjProps->FInit(pPropCache, NULL);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
m_pPropCache = pPropCache;
|
|
pDispatch->Release();
|
|
|
|
RRETURN(S_OK);
|
|
|
|
error:
|
|
|
|
if(pPropCache != NULL)
|
|
delete pPropCache;
|
|
|
|
if(pDispatch != NULL)
|
|
pDispatch->Release();
|
|
|
|
if(m_pObjProps != NULL) {
|
|
delete m_pObjProps;
|
|
m_pObjProps = NULL;
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: QueryInterface
|
|
//
|
|
// Synopsis: Implements QI for the UMI object.
|
|
//
|
|
// Arguments
|
|
//
|
|
// iid interface requested
|
|
// ppInterface Returns pointer to interface requested. NULL if interface
|
|
// is not supported.
|
|
//
|
|
// Returns: S_OK on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppInterface to return interface pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::QueryInterface(
|
|
REFIID iid,
|
|
LPVOID *ppInterface
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IUnknown *pTmpIntfPtr = NULL;
|
|
|
|
if(NULL == ppInterface)
|
|
RRETURN(E_INVALIDARG);
|
|
|
|
*ppInterface = NULL;
|
|
|
|
if(IsEqualIID(iid, IID_IUnknown))
|
|
*ppInterface = (IUmiObject *) this;
|
|
else if(IsEqualIID(iid, IID_IUmiObject))
|
|
*ppInterface = (IUmiObject *) this;
|
|
else if(IsEqualIID(iid, IID_IUmiContainer)) {
|
|
// check if underlying WinNT object is a container
|
|
if(m_pIADsContainer != NULL)
|
|
*ppInterface = (IUmiContainer *) this;
|
|
else
|
|
RRETURN(E_NOINTERFACE);
|
|
}
|
|
else if(IsEqualIID(iid, IID_IUmiBaseObject))
|
|
*ppInterface = (IUmiBaseObject *) this;
|
|
else if(IsEqualIID(iid, IID_IUmiPropList))
|
|
*ppInterface = (IUmiPropList *) this;
|
|
else if(IsEqualIID(iid, IID_IUmiCustomInterfaceFactory))
|
|
*ppInterface = (IUmiCustomInterfaceFactory *) this;
|
|
else if(IsEqualIID(iid, IID_IUmiADSIPrivate))
|
|
*ppInterface = (IUmiADSIPrivate *) this;
|
|
else
|
|
RRETURN(E_NOINTERFACE);
|
|
|
|
AddRef();
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: Clone
|
|
//
|
|
// Synopsis: Implements IUmiObject::Clone. Creates a new uncommitted object
|
|
// and copies over all properties from the source to destination.
|
|
// The source may be Refresh()ed if necessary.
|
|
//
|
|
// Arguments
|
|
//
|
|
// uFlags Flags for Clone(). Must be 0 for now.
|
|
// riid Interface ID requested on the cloned object
|
|
// pCopy Returns interface pointer requested
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pCopy to return the interface requested.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::Clone(
|
|
ULONG uFlags,
|
|
REFIID riid,
|
|
LPVOID *pCopy
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
BSTR bstrADsPath = NULL, bstrParent = NULL;
|
|
BSTR bstrClass = NULL, bstrName = NULL;
|
|
IUnknown *pUnknown = NULL, *pUnkParent = NULL;
|
|
IDispatch *pDispatch = NULL;
|
|
IADsContainer *pIADsCont = NULL;
|
|
IUmiObject *pUmiObj = NULL;
|
|
IUmiADSIPrivate *pUmiPrivate = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if(NULL == pCopy)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if( (NULL == m_pCoreObj) || (NULL == m_pIADs) )
|
|
// shouldn't happen, but just being paranoid
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
*pCopy = NULL;
|
|
|
|
if(ADS_OBJECT_BOUND == m_pCoreObj->GetObjectState()) {
|
|
// object exists on server
|
|
if(FALSE == m_fRefreshDone) {
|
|
hr = m_pCoreObj->ImplicitGetInfo();
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
hr = m_pIADs->get_ADsPath(&bstrADsPath);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
m_pCreds->SetUmiFlag();
|
|
|
|
hr = GetObject(
|
|
bstrADsPath,
|
|
(LPVOID *) &pUnknown,
|
|
*m_pCreds
|
|
);
|
|
|
|
m_pCreds->ResetUmiFlag();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUnknown->QueryInterface(IID_IUmiObject, (LPVOID *) &pUmiObj);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
else if(ADS_OBJECT_UNBOUND == m_pCoreObj->GetObjectState()) {
|
|
// object not yet committed to server. We don't have to refresh the
|
|
// cache since the object is not yet committed. Get the parent container
|
|
// and call Create() on it.
|
|
|
|
hr = m_pIADs->get_Parent(&bstrParent);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
m_pCreds->SetUmiFlag();
|
|
|
|
hr = GetObject(
|
|
bstrParent,
|
|
(LPVOID *) &pUnkParent,
|
|
*m_pCreds
|
|
);
|
|
m_pCreds->ResetUmiFlag();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUnkParent->QueryInterface(
|
|
IID_IUmiADSIPrivate,
|
|
(LPVOID *) &pUmiPrivate
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUmiPrivate->GetContainer((void **) &pIADsCont);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
ADsAssert(pIADsCont != NULL);
|
|
|
|
// get the class and name of this object
|
|
hr = m_pIADs->get_Class(&bstrClass);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = m_pIADs->get_Name(&bstrName);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
pUmiPrivate->SetUmiFlag();
|
|
|
|
// now Create() the cloned object
|
|
hr = pIADsCont->Create(
|
|
bstrClass,
|
|
bstrName,
|
|
&pDispatch
|
|
);
|
|
|
|
pUmiPrivate->ResetUmiFlag();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pDispatch->QueryInterface(IID_IUmiObject, (LPVOID *) &pUmiObj);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
else // unknown state, shouldn't happen.
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
// copy over the attributes in the property cache
|
|
hr = CopyPropCache(pUmiObj, (IUmiObject *) this);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUmiObj->QueryInterface(riid, pCopy);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
error:
|
|
|
|
if(bstrADsPath != NULL)
|
|
SysFreeString(bstrADsPath);
|
|
|
|
if(bstrParent != NULL)
|
|
SysFreeString(bstrParent);
|
|
|
|
if(bstrClass != NULL)
|
|
SysFreeString(bstrClass);
|
|
|
|
if(bstrName != NULL)
|
|
SysFreeString(bstrName);
|
|
|
|
if(pUnknown != NULL)
|
|
pUnknown->Release();
|
|
|
|
if(pUnkParent != NULL)
|
|
pUnkParent->Release();
|
|
|
|
if(pDispatch != NULL)
|
|
pDispatch->Release();
|
|
|
|
if(pIADsCont != NULL)
|
|
pIADsCont->Release();
|
|
|
|
if(pUmiObj != NULL)
|
|
pUmiObj->Release();
|
|
|
|
if(pUmiPrivate != NULL)
|
|
pUmiPrivate->Release();
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: CopyPropCache
|
|
//
|
|
// Synopsis: Copies the cache of one IUmiObject to another IUmiObject.
|
|
//
|
|
// Arguments
|
|
//
|
|
// pDest IUmiObject interface pointer of destination
|
|
// pSrc IUmiObject interface pointer of source
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::CopyPropCache(
|
|
IUmiObject *pDest,
|
|
IUmiObject *pSrc
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulIndex = 0, ulPutFlag = 0;
|
|
LPWSTR pszPropName = NULL;
|
|
UMI_PROPERTY_VALUES *pUmiPropNames = NULL, *pUmiProp = NULL;
|
|
|
|
ADsAssert( (pDest != NULL) && (pSrc != NULL) );
|
|
|
|
// get the names of the properties in cache.
|
|
hr = pSrc->GetProps(
|
|
NULL,
|
|
0,
|
|
UMI_FLAG_GETPROPS_NAMES,
|
|
&pUmiPropNames
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// copy over each property
|
|
for(ulIndex = 0; ulIndex < pUmiPropNames->uCount; ulIndex++) {
|
|
pszPropName = pUmiPropNames->pPropArray[ulIndex].pszPropertyName;
|
|
|
|
if(NULL == pszPropName)
|
|
// shouldn't happen, just being paranoid.
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
hr = pSrc->Get(
|
|
pszPropName,
|
|
UMI_FLAG_PROVIDER_CACHE,
|
|
&pUmiProp
|
|
);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// if the property was updated in cache, we need to mark it as updated
|
|
// in the destination object's cache also. Otherwise, mark the
|
|
// property as clean in the destination object's cache.
|
|
if(UMI_OPERATION_UPDATE == pUmiProp->pPropArray->uOperationType)
|
|
ulPutFlag = 0;
|
|
else
|
|
ulPutFlag = UMI_INTERNAL_FLAG_MARK_AS_CLEAN;
|
|
|
|
pUmiProp->pPropArray->uOperationType = UMI_OPERATION_UPDATE;
|
|
|
|
hr = pDest->Put(
|
|
pszPropName,
|
|
ulPutFlag,
|
|
pUmiProp
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
pSrc->FreeMemory(0, pUmiProp);
|
|
pUmiProp = NULL;
|
|
}
|
|
|
|
pSrc->FreeMemory(0, pUmiPropNames);
|
|
|
|
error:
|
|
|
|
if(FAILED(hr)) {
|
|
if(pUmiProp != NULL)
|
|
pSrc->FreeMemory(0, pUmiProp);
|
|
if(pUmiPropNames != NULL)
|
|
pSrc->FreeMemory(0, pUmiPropNames);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: Refresh
|
|
//
|
|
// Synopsis: Implements IUmiObject::Refresh. Calls GetInfo on WinNT
|
|
// object to refresh the cache. GetInfoEx is implemented by
|
|
// just calling GetInfo in the WinNT provider.
|
|
//
|
|
// Arguments
|
|
//
|
|
// uFlags Flags for Refresh. Must be 0 for now.
|
|
// uNameCount Number of attributes to refresh
|
|
// pszNames Names of attributes to refresh
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::Refresh(
|
|
ULONG uFlags,
|
|
ULONG uNameCount,
|
|
LPWSTR *pszNames
|
|
)
|
|
{
|
|
ULONG i = 0;
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if( (uFlags != UMI_FLAG_REFRESH_ALL) &&
|
|
(uFlags != UMI_FLAG_REFRESH_PARTIAL) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if( ((NULL == pszNames) && (uNameCount != 0)) ||
|
|
((pszNames != NULL) && (0 == uNameCount)) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
// ensure all attributes are valid
|
|
for(i = 0; i < uNameCount; i++)
|
|
if(NULL == pszNames[i])
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(UMI_FLAG_REFRESH_PARTIAL == uFlags) {
|
|
// do an implicit GetInfo on the WinNT object
|
|
if(NULL == m_pCoreObj)
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
if(uNameCount != 0) {
|
|
// can't specify UMI_FLAG_REFRESH_PARTIAL and attribute names
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
}
|
|
|
|
hr = m_pCoreObj->ImplicitGetInfo();
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
else {
|
|
if(NULL == m_pIADs)
|
|
// shouldn't happen, but just being paranoid
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
hr = m_pIADs->GetInfo();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
m_fRefreshDone = TRUE;
|
|
|
|
error:
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: Commit
|
|
//
|
|
// Synopsis: Implements IUmiObject::Commit. Calls SetInfo on WinNT
|
|
// object to commit changes made to the cache.
|
|
//
|
|
// Arguments
|
|
//
|
|
// uFlags Flags for Refresh.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::Commit(ULONG uFlags)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
|
|
SetLastStatus(0);
|
|
|
|
// CIMOM always calls with UMI_DONT_COMMIT_SECURITY_DESCRIPTOR set. Ignore
|
|
// this flag as it is not meaningful on WinNT.
|
|
if( (uFlags != 0) && (uFlags != UMI_DONT_COMMIT_SECURITY_DESCRIPTOR) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if(NULL == m_pIADs)
|
|
// shouldn't happen, but just being paranoid
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
hr = m_pIADs->SetInfo();
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
error:
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// IUmiPropList methods
|
|
//
|
|
// These are implemented by invoking the corresponding method in the
|
|
// CUmiPropList object that implements object properties. For a description
|
|
// of these methods, refer to cumiprop.cxx
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::Put(
|
|
LPCWSTR pszName,
|
|
ULONG uFlags,
|
|
UMI_PROPERTY_VALUES *pProp
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->Put(
|
|
pszName,
|
|
uFlags,
|
|
pProp
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::Get(
|
|
LPCWSTR pszName,
|
|
ULONG uFlags,
|
|
UMI_PROPERTY_VALUES **ppProp
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->Get(
|
|
pszName,
|
|
uFlags,
|
|
ppProp
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::GetAs(
|
|
LPCWSTR pszName,
|
|
ULONG uFlags,
|
|
ULONG uCoercionType,
|
|
UMI_PROPERTY_VALUES **ppProp
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->GetAs(
|
|
pszName,
|
|
uFlags,
|
|
uCoercionType,
|
|
ppProp
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::FreeMemory(
|
|
ULONG uReserved,
|
|
LPVOID pMem
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->FreeMemory(
|
|
uReserved,
|
|
pMem
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::GetAt(
|
|
LPCWSTR pszName,
|
|
ULONG uFlags,
|
|
ULONG uBufferLength,
|
|
LPVOID pExistingMem
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->GetAt(
|
|
pszName,
|
|
uFlags,
|
|
uBufferLength,
|
|
pExistingMem
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::GetProps(
|
|
LPCWSTR *pszNames,
|
|
ULONG uNameCount,
|
|
ULONG uFlags,
|
|
UMI_PROPERTY_VALUES **pProps
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->GetProps(
|
|
pszNames,
|
|
uNameCount,
|
|
uFlags,
|
|
pProps
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::PutProps(
|
|
LPCWSTR *pszNames,
|
|
ULONG uNameCount,
|
|
ULONG uFlags,
|
|
UMI_PROPERTY_VALUES *pProps
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->PutProps(
|
|
pszNames,
|
|
uNameCount,
|
|
uFlags,
|
|
pProps
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::PutFrom(
|
|
LPCWSTR pszName,
|
|
ULONG uFlags,
|
|
ULONG uBufferLength,
|
|
LPVOID pExistingMem
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->PutFrom(
|
|
pszName,
|
|
uFlags,
|
|
uBufferLength,
|
|
pExistingMem
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
HRESULT CUmiObject::Delete(
|
|
LPCWSTR pszName,
|
|
ULONG uFlags
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONG ulStatus = 0;
|
|
IID iid;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(NULL == m_pObjProps) {
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
hr = m_pObjProps->Delete(
|
|
pszName,
|
|
uFlags
|
|
);
|
|
|
|
if(FAILED(hr)) {
|
|
m_pObjProps->GetLastStatus( // ignore error return
|
|
0,
|
|
&ulStatus,
|
|
iid,
|
|
NULL
|
|
);
|
|
|
|
SetLastStatus(ulStatus);
|
|
}
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetLastStatus
|
|
//
|
|
// Synopsis: Returns status or error code from the last operation. Currently
|
|
// only numeric status is returned i.e, no error objects are
|
|
// returned. Implements IUmiBaseObject::GetLastStatus().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// puSpecificStatus Returns status code
|
|
// riid IID requested. Ignored currently.
|
|
// pStatusObj Returns interface requested. Always returns NULL currently.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *puSpecificStatus to return status code.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::GetLastStatus(
|
|
ULONG uFlags,
|
|
ULONG *puSpecificStatus,
|
|
REFIID riid,
|
|
LPVOID *pStatusObj
|
|
)
|
|
{
|
|
if(pStatusObj != NULL)
|
|
*pStatusObj = NULL;
|
|
|
|
if(puSpecificStatus != NULL)
|
|
*puSpecificStatus = 0;
|
|
|
|
if(uFlags != 0)
|
|
RRETURN(UMI_E_INVALID_FLAGS);
|
|
|
|
if(NULL == puSpecificStatus)
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
|
|
*puSpecificStatus = m_ulErrorStatus;
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: SetLastStatus
|
|
//
|
|
// Synopsis: Sets the status of the last operation.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// ulStatus Status to be set
|
|
//
|
|
// Returns: Nothing
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void CUmiObject::SetLastStatus(ULONG ulStatus)
|
|
{
|
|
m_ulErrorStatus = ulStatus;
|
|
|
|
return;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetInterfacePropList
|
|
//
|
|
// Synopsis: Returns a pointer to the interface property list implementation
|
|
// for the connection object. Implements
|
|
// IUmiBaseObject::GetInterfacePropList().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// pPropList Returns pointer to IUmiPropertyList interface
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pPropList to return interface pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::GetInterfacePropList(
|
|
ULONG uFlags,
|
|
IUmiPropList **pPropList
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if(NULL == pPropList)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
ADsAssert(m_pIntfProps != NULL);
|
|
|
|
hr = m_pIntfProps->QueryInterface(IID_IUmiPropList, (void **) pPropList);
|
|
|
|
error:
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: IsRelativePath
|
|
//
|
|
// Synopsis: Checks if a path is relative or absolute
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pURL IUmiURL interface containing the path
|
|
//
|
|
// Returns: TRUE if the path is relative, FALSE otherwise
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL CUmiObject::IsRelativePath(IUmiURL *pURL)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONGLONG PathType = 0;
|
|
|
|
ADsAssert(pURL != NULL);
|
|
|
|
hr = pURL->GetPathInfo(
|
|
0,
|
|
&PathType
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if(PathType & UMIPATH_INFO_RELATIVE_PATH)
|
|
RRETURN(TRUE);
|
|
else
|
|
RRETURN(FALSE);
|
|
|
|
error:
|
|
|
|
RRETURN(FALSE);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetClassAndPath
|
|
//
|
|
// Synopsis: Obtains the class name and path from a relative UMI path.
|
|
// The class name and value are mandatory. The key is optional.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pszPath String containing the path
|
|
// ppszClass Returns string containing the class name
|
|
// ppszPath Returns string containing the path
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppszClass and *ppszPath
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::GetClassAndPath(
|
|
LPWSTR pszPath,
|
|
LPWSTR *ppszClass,
|
|
LPWSTR *ppszPath
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
WCHAR *pSeparator = NULL, *pValSeparator = NULL;
|
|
|
|
ADsAssert( (pszPath != NULL) && (ppszClass != NULL) &&
|
|
(ppszPath != NULL) );
|
|
|
|
*ppszClass = NULL;
|
|
*ppszPath = NULL;
|
|
|
|
// look for the '=' in the relative path
|
|
if(NULL == (pValSeparator = wcschr(pszPath, VALUE_SEPARATOR)))
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
|
|
*pValSeparator = L'\0';
|
|
*ppszPath = AllocADsStr(pValSeparator+1);
|
|
if(NULL == *ppszPath)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
if(NULL == (pSeparator = wcschr(pszPath, CLASS_SEPARATOR))) {
|
|
// path does not have a key in it
|
|
*ppszClass = AllocADsStr(pszPath);
|
|
if(NULL == *ppszClass)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
}
|
|
else {
|
|
// path has a key. Make sure it is "Name".
|
|
*pSeparator = L'\0';
|
|
|
|
if(_wcsicmp(pSeparator+1, WINNT_KEY_NAME))
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
|
|
*ppszClass = AllocADsStr(pszPath);
|
|
if(NULL == *ppszClass)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
}
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
|
|
error:
|
|
|
|
if(*ppszPath != NULL)
|
|
FreeADsStr(*ppszPath);
|
|
|
|
if(*ppszClass != NULL)
|
|
FreeADsStr(*ppszClass);
|
|
|
|
*ppszPath = *ppszClass = NULL;
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: Open
|
|
//
|
|
// Synopsis: Opens the object specified by a URL. URL has to be a relative
|
|
// UMI path. Implements IUmiContainer::Open().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pURL Pointer to an IUmiURL interface
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// TargetIID Interface requested
|
|
// ppInterface Returns pointer to interface requested
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppInterface to return interface pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::Open(
|
|
IUmiURL *pURL,
|
|
ULONG uFlags,
|
|
REFIID TargetIID,
|
|
LPVOID *ppInterface
|
|
)
|
|
{
|
|
BOOL fIsRelPath = FALSE;
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
WCHAR pszUrl[MAX_URL+1];
|
|
WCHAR *pszLongUrl = pszUrl;
|
|
ULONG ulUrlLen = MAX_URL;
|
|
WCHAR *pszClass = NULL, *pszPath = NULL;
|
|
IDispatch *pIDispatch = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if( (NULL == pURL) || (NULL == ppInterface) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(NULL == m_pIADsContainer)
|
|
// shouldn't happen, but just in case...
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
// Get the path from the URL
|
|
hr = pURL->Get(0, &ulUrlLen, pszUrl);
|
|
|
|
if(WBEM_E_BUFFER_TOO_SMALL == hr) {
|
|
// need to allocate more memory for URL
|
|
pszLongUrl = (WCHAR *) AllocADsMem(ulUrlLen * sizeof(WCHAR));
|
|
if(NULL == pszLongUrl)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
hr = pURL->Get(0, &ulUrlLen, pszLongUrl);
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// Check if the path is relative or absolute
|
|
fIsRelPath = IsRelativePath(pURL);
|
|
|
|
if(TRUE == fIsRelPath) {
|
|
// check if the caller specified the class as part of the path
|
|
hr = GetClassAndPath(pszLongUrl, &pszClass, &pszPath);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
m_pCreds->SetUmiFlag();
|
|
|
|
hr = m_pIADsContainer->GetObject(
|
|
pszClass,
|
|
pszPath,
|
|
&pIDispatch
|
|
);
|
|
|
|
m_pCreds->ResetUmiFlag();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pIDispatch->QueryInterface(
|
|
TargetIID,
|
|
ppInterface
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
} // if(TRUE == fIsRelPath
|
|
else {
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
}
|
|
|
|
error:
|
|
|
|
if(pIDispatch != NULL)
|
|
pIDispatch->Release();
|
|
|
|
if(pszClass != NULL)
|
|
FreeADsMem(pszClass);
|
|
|
|
if(pszPath != NULL)
|
|
FreeADsMem(pszPath);
|
|
|
|
if(pszLongUrl != pszUrl)
|
|
FreeADsMem(pszLongUrl);
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: PutObject
|
|
//
|
|
// Synopsis: Commits an object into the container. Not implemented currently.
|
|
// Implements IUmiContainer::Put().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// TargetIID IID of nterface pointer sent in
|
|
// pInterface Interface pointer sent in
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppInterface to return interface pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::PutObject(
|
|
ULONG uFlags,
|
|
REFIID TargetIID,
|
|
LPVOID pInterface
|
|
)
|
|
{
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: DeleteObject
|
|
//
|
|
// Synopsis: Deletes the object specified by the relative UMI path.
|
|
// Implements IUmiContainer::Delete().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pURL Pointer to an IUmiURL interface
|
|
// uFlags Reserved. Must be 0 for now.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::DeleteObject(
|
|
IUmiURL *pURL,
|
|
ULONG uFlags
|
|
)
|
|
{
|
|
ULONG ulUrlLen = MAX_URL;
|
|
WCHAR pszUrl[MAX_URL+1], *pszClass = NULL, *pszPath = NULL;
|
|
WCHAR *pszLongUrl = pszUrl;
|
|
BOOL fIsRelPath = FALSE;
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if(NULL == pURL)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(NULL == m_pIADsContainer)
|
|
// shouldn't happen, but just in case...
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
// Get the path from the URL
|
|
hr = pURL->Get(0, &ulUrlLen, pszUrl);
|
|
|
|
if(WBEM_E_BUFFER_TOO_SMALL == hr) {
|
|
// need to allocate more memory for URL
|
|
pszLongUrl = (WCHAR *) AllocADsMem(ulUrlLen * sizeof(WCHAR));
|
|
if(NULL == pszLongUrl)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
hr = pURL->Get(0, &ulUrlLen, pszLongUrl);
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// Check if the path is relative or absolute
|
|
fIsRelPath = IsRelativePath(pURL);
|
|
|
|
if(TRUE == fIsRelPath) {
|
|
// check if the caller specified the class as part of the path
|
|
hr = GetClassAndPath(pszLongUrl, &pszClass, &pszPath);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
m_pCreds->SetUmiFlag();
|
|
|
|
hr = m_pIADsContainer->Delete(
|
|
pszClass,
|
|
pszPath
|
|
);
|
|
|
|
m_pCreds->ResetUmiFlag();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
} // if(TRUE == fIsRelPath
|
|
else {
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
}
|
|
|
|
error:
|
|
|
|
if(pszClass != NULL)
|
|
FreeADsMem(pszClass);
|
|
|
|
if(pszPath != NULL)
|
|
FreeADsMem(pszPath);
|
|
|
|
if(pszLongUrl != pszUrl)
|
|
FreeADsMem(pszLongUrl);
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: Create
|
|
//
|
|
// Synopsis: Creates the object specified by the relative UMI path.
|
|
// Implements IUmiContainer::Create().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pURL Pointer to an IUmiURL interface
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// ppNewObj Returns pointer to IUmiObject interface on new object
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pNewObject to return the IUmiObject interface
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::Create(
|
|
IUmiURL *pURL,
|
|
ULONG uFlags,
|
|
IUmiObject **ppNewObj
|
|
)
|
|
{
|
|
ULONG ulUrlLen = MAX_URL;
|
|
WCHAR pszUrl[MAX_URL+1], *pszClass = NULL, *pszPath = NULL;
|
|
WCHAR *pszLongUrl = pszUrl;
|
|
BOOL fIsRelPath = FALSE;
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
IDispatch *pIDispatch = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if( (NULL == pURL) || (NULL == ppNewObj) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(NULL == m_pIADsContainer)
|
|
// shouldn't happen, but just in case...
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
// Get the path from the URL
|
|
hr = pURL->Get(0, &ulUrlLen, pszUrl);
|
|
|
|
if(WBEM_E_BUFFER_TOO_SMALL == hr) {
|
|
// need to allocate more memory for URL
|
|
pszLongUrl = (WCHAR *) AllocADsMem(ulUrlLen * sizeof(WCHAR));
|
|
if(NULL == pszLongUrl)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
hr = pURL->Get(0, &ulUrlLen, pszLongUrl);
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// Check if the path is relative or absolute
|
|
fIsRelPath = IsRelativePath(pURL);
|
|
|
|
if(TRUE == fIsRelPath) {
|
|
// check if the caller specified the class as part of the path
|
|
hr = GetClassAndPath(pszLongUrl, &pszClass, &pszPath);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
m_pCreds->SetUmiFlag();
|
|
|
|
hr = m_pIADsContainer->Create(
|
|
pszClass,
|
|
pszPath,
|
|
&pIDispatch
|
|
);
|
|
|
|
m_pCreds->ResetUmiFlag();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pIDispatch->QueryInterface(
|
|
IID_IUmiObject,
|
|
(void **) ppNewObj
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
} // if(TRUE == fIsRelPath
|
|
else {
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
}
|
|
|
|
error:
|
|
|
|
if(pIDispatch != NULL)
|
|
pIDispatch->Release();
|
|
|
|
if(pszClass != NULL)
|
|
FreeADsMem(pszClass);
|
|
|
|
if(pszPath != NULL)
|
|
FreeADsMem(pszPath);
|
|
|
|
if(pszLongUrl != pszUrl)
|
|
FreeADsMem(pszLongUrl);
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: Move
|
|
//
|
|
// Synopsis: Moves a specified object into the container. Implements
|
|
// IUmiContainer::Move().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// pOldURL URL of the object to be moved
|
|
// pNewURL New URL of the object within the container. If NULL, the new
|
|
// name will be the same as the old one.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::Move(
|
|
ULONG uFlags,
|
|
IUmiURL *pOldURL,
|
|
IUmiURL *pNewURL
|
|
)
|
|
{
|
|
ULONG ulUrlLen = MAX_URL;
|
|
WCHAR pszNewUrl[MAX_URL+1], pszOldUrl[MAX_URL+1];
|
|
WCHAR *pszLongNewUrl = pszNewUrl, *pszLongOldUrl = pszOldUrl;
|
|
WCHAR *pszDstPath = NULL, *pszTmpStr = NULL;
|
|
WCHAR *pszClass = NULL;
|
|
BOOL fIsRelPath = FALSE;
|
|
IDispatch *pIDispatch = NULL;
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONGLONG PathType = 0;
|
|
WCHAR *pSeparator = NULL;
|
|
DWORD dwNumComponents = 0, dwIndex = 0;
|
|
LPWSTR *ppszClasses = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if(NULL == pOldURL)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(NULL == m_pIADsContainer)
|
|
// shouldn't happen, but just in case...
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
// Get the path from the URL
|
|
if(pNewURL != NULL) {
|
|
hr = pNewURL->Get(0, &ulUrlLen, pszNewUrl);
|
|
|
|
if(WBEM_E_BUFFER_TOO_SMALL == hr) {
|
|
// need to allocate more memory for URL
|
|
pszLongNewUrl = (WCHAR *) AllocADsMem(ulUrlLen * sizeof(WCHAR));
|
|
if(NULL == pszLongNewUrl)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
hr = pNewURL->Get(0, &ulUrlLen, pszLongNewUrl);
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// Check if the path is relative or absolute
|
|
fIsRelPath = IsRelativePath(pNewURL);
|
|
}
|
|
else {
|
|
fIsRelPath = TRUE;
|
|
pszDstPath = NULL;
|
|
}
|
|
|
|
// check if old path is native or UMI path
|
|
hr = pOldURL->GetPathInfo(0, &PathType);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if(PathType & UMIPATH_INFO_NATIVE_STRING) {
|
|
// Get the native path from the URL
|
|
ulUrlLen = MAX_URL;
|
|
hr = pOldURL->Get(0, &ulUrlLen, pszOldUrl);
|
|
|
|
if(WBEM_E_BUFFER_TOO_SMALL == hr) {
|
|
// need to allocate more memory for URL
|
|
pszLongOldUrl = (WCHAR *) AllocADsMem(ulUrlLen * sizeof(WCHAR));
|
|
if(NULL == pszLongOldUrl)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
hr = pOldURL->Get(0, &ulUrlLen, pszLongOldUrl);
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
else {
|
|
// assume UMI path if not native
|
|
hr = UmiToWinNTPath(
|
|
pOldURL,
|
|
&pszLongOldUrl,
|
|
&dwNumComponents,
|
|
&ppszClasses
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// check to ensure that the UMI path had the expected object classes
|
|
hr = CheckClasses(dwNumComponents, ppszClasses);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
if(TRUE == fIsRelPath) {
|
|
if(pNewURL != NULL) {
|
|
hr = GetClassAndPath(pszLongNewUrl, &pszClass, &pszDstPath);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// Make sure that if the old path had a class specified in the path,
|
|
// then the new path also if of the same class
|
|
if(NULL == (pSeparator = wcschr(pszLongOldUrl,
|
|
NATIVE_CLASS_SEPARATOR))) {
|
|
// no class specified in the old path. Must have been a native path.
|
|
// Append class to old path.
|
|
pszTmpStr = (WCHAR *) AllocADsMem(
|
|
(wcslen(pszLongOldUrl)+MAX_CLASS) *
|
|
sizeof(WCHAR) );
|
|
if(NULL == pszTmpStr)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
wcscpy(pszTmpStr, pszLongOldUrl);
|
|
wcscat(pszTmpStr, L",");
|
|
wcscat(pszTmpStr, pszClass);
|
|
|
|
if(pszLongOldUrl != pszOldUrl)
|
|
FreeADsMem(pszLongOldUrl);
|
|
|
|
pszLongOldUrl = pszTmpStr;
|
|
}
|
|
else {
|
|
// old path already had a class in it
|
|
if(_wcsicmp(pSeparator+1, pszClass))
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
}
|
|
} // if(pNewUrl != NULL)
|
|
|
|
m_pCreds->SetUmiFlag();
|
|
|
|
hr = m_pIADsContainer->MoveHere(
|
|
pszLongOldUrl,
|
|
pszDstPath,
|
|
&pIDispatch
|
|
);
|
|
|
|
m_pCreds->ResetUmiFlag();
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
} // if(TRUE == fIsRelPath)
|
|
else {
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
}
|
|
|
|
error:
|
|
|
|
if(pIDispatch != NULL)
|
|
pIDispatch->Release();
|
|
|
|
if(pszLongOldUrl != pszOldUrl)
|
|
FreeADsMem(pszLongOldUrl);
|
|
|
|
if(pszLongNewUrl != pszNewUrl)
|
|
FreeADsMem(pszLongNewUrl);
|
|
|
|
if(pszClass != NULL)
|
|
FreeADsStr(pszClass);
|
|
|
|
if(pszDstPath != NULL)
|
|
FreeADsStr(pszDstPath);
|
|
|
|
if(ppszClasses != NULL) {
|
|
for(dwIndex = 0; dwIndex < dwNumComponents; dwIndex++) {
|
|
if(ppszClasses[dwIndex] != NULL)
|
|
FreeADsStr(ppszClasses[dwIndex]);
|
|
}
|
|
FreeADsMem(ppszClasses);
|
|
}
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: CreateEnum
|
|
//
|
|
// Synopsis: Creates an enumerator within a container. The enumerator is
|
|
// a IUmiCursor interface pointer. The caller can optionally set
|
|
// a filter on the cursor and then enumerate the contents of the
|
|
// container. The actual enumeration of the container does
|
|
// not happen in this function. It is deferred to the point
|
|
// when the cursor is used to enumerate the results.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pszEnumContext Not used. Must be NULL.
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// TargetIID Interface requested. Has to be IUmiCursor.
|
|
// ppInterface Returns the IUmiCursor interface pointer
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppInterface to return the IUmiCursor interface
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::CreateEnum(
|
|
IUmiURL *pszEnumContext,
|
|
ULONG uFlags,
|
|
REFIID TargetIID,
|
|
LPVOID *ppInterface
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
IUnknown *pEnumerator = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if( (pszEnumContext != NULL) || (NULL == ppInterface) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(!IsEqualIID(IID_IUmiCursor, TargetIID))
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
*ppInterface = NULL;
|
|
|
|
if(NULL == m_pIADsContainer)
|
|
// shouldn't happen, but just in case...
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
hr = CUmiCursor::CreateCursor(m_pCreds, m_pUnkInner, TargetIID,
|
|
ppInterface);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
error:
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: ExecQuery
|
|
//
|
|
// Synopsis: Executes a query in a container. Not implemented on WinNT.
|
|
// Implements IUmiContainer::ExecQuery().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// pQuery IUmiQuery interface containing the query
|
|
// uFlags Reserved. Must be 0 for now.
|
|
// TargetIID Interface requested
|
|
// ppInterface Returns pointer to interface requested
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppInterface to return interface pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::ExecQuery(
|
|
IUmiQuery *pQuery,
|
|
ULONG uFlags,
|
|
REFIID TargetIID,
|
|
LPVOID *ppInterface
|
|
)
|
|
{
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetCLSIDForIID
|
|
//
|
|
// Synopsis: Returns the CLSID corresponding to a given interface IID. If
|
|
// the interface is one of the interfaces implemented by the
|
|
// underlying WinNT object, then CLSID_WinNTObject is returned.
|
|
// If the IID is one of the interfaces implemented by an
|
|
// extension object, then the extension's CLSID is returned.
|
|
// Implements IUmiCustomInterfaceFactory::GetCLSIDForIID.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// riid Interface ID for which we want to find the CLSID
|
|
// lFlags Reserved. Must be 0.
|
|
// pCLSID Returns the CLSID corresponding to the IID.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pCLSID to return CLSID.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::GetCLSIDForIID(
|
|
REFIID riid,
|
|
long lFlags,
|
|
CLSID *pCLSID
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IUnknown *pUnknown = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if( (lFlags != 0) || (NULL == pCLSID) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(m_pExtMgr != NULL) {
|
|
// check if there is any extension which supports this IID
|
|
hr = m_pExtMgr->GetCLSIDForIID(
|
|
riid,
|
|
lFlags,
|
|
pCLSID
|
|
);
|
|
if(SUCCEEDED(hr))
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
// check if the underlying WinNT object supports this IID
|
|
hr = m_pUnkInner->QueryInterface(riid, (void **) &pUnknown);
|
|
if(SUCCEEDED(hr)) {
|
|
pUnknown->Release();
|
|
memcpy(pCLSID, &CLSID_WinNTObject, sizeof(GUID));
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
error:
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetObjectByCLSID
|
|
//
|
|
// Synopsis: Returns a pointer to a requested interface on the object
|
|
// specified by a CLSID. The object specified by the CLSID is
|
|
// aggregated by the specified outer unknown. The interface
|
|
// returned is a non-delegating interface on the object.
|
|
// Implements IUmiCustomInterfaceFactory::GetObjectByCLSID.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// clsid CLSID of object on which interface should be obtained
|
|
// pUnkOuter Aggregating outer unknown.
|
|
// dwClsContext Context for running executable code.
|
|
// riid Interface requested. Has to be IID_IUnknown.
|
|
// lFlags Reserved. Must be 0.
|
|
// ppInterface Returns requested interface
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppInterface to return requested interface
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::GetObjectByCLSID(
|
|
CLSID clsid,
|
|
IUnknown *pUnkOuter,
|
|
DWORD dwClsContext,
|
|
REFIID riid,
|
|
long lFlags,
|
|
void **ppInterface
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IUnknown *pCurOuterUnk = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if( (lFlags != 0) || (NULL == pUnkOuter) || (NULL == ppInterface) ||
|
|
(dwClsContext != CLSCTX_INPROC_SERVER) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
// ensure outer unknown specified is same as what is on the WinNT object
|
|
if(TRUE == m_fOuterUnkSet) {
|
|
pCurOuterUnk = m_pCoreObj->GetOuterUnknown();
|
|
|
|
if(pCurOuterUnk != pUnkOuter)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
}
|
|
|
|
// Interface requested has to be IID_IUnknown if there is an outer unknown
|
|
if (!IsEqualIID(riid, IID_IUnknown))
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(!IsEqualCLSID(clsid, CLSID_WinNTObject)) {
|
|
// has to be a CLSID of an extension object
|
|
if(m_pExtMgr != NULL) {
|
|
|
|
hr = m_pExtMgr->GetObjectByCLSID(
|
|
clsid,
|
|
pUnkOuter,
|
|
riid,
|
|
ppInterface
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// successfully got the interface
|
|
m_pCoreObj->SetOuterUnknown(pUnkOuter);
|
|
m_fOuterUnkSet = TRUE;
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
else
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG); // bad CLSID
|
|
}
|
|
|
|
// CLSID == CLSID_WinNTObject. This has to be an interface on the
|
|
// underlying WinNT object.
|
|
|
|
m_pCoreObj->SetOuterUnknown(pUnkOuter);
|
|
m_fOuterUnkSet = TRUE;
|
|
|
|
*ppInterface = m_pUnkInner;
|
|
m_pUnkInner->AddRef();
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
|
|
error:
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetCLSIDForNames
|
|
//
|
|
// Synopsis: Returns the CLSID of the object that supports a specified
|
|
// method/property. Also returns DISPIDs for the property/method.
|
|
// Implements IUmiCustomInterfaceFactory::GetCLSIDForNames.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// rgszNames Names to be mapped
|
|
// cNames Number of names to be mapped
|
|
// lcid Locale in which to interpret the names
|
|
// rgDispId Returns DISPID
|
|
// lFlags Reserved. Must be 0.
|
|
// pCLSID Returns CLSID of object which supports this property/method.
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pCLSID to return the CLSID.
|
|
// *rgDispId to return the DISPIDs.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::GetCLSIDForNames(
|
|
LPOLESTR *rgszNames,
|
|
UINT cNames,
|
|
LCID lcid,
|
|
DISPID *rgDispId,
|
|
long lFlags,
|
|
CLSID *pCLSID
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch *pDispatch = NULL;
|
|
|
|
SetLastStatus(0);
|
|
|
|
if( (lFlags != 0) || (NULL == pCLSID) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if(0 == cNames)
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
|
|
if( (NULL == rgszNames) || (NULL == rgDispId) )
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
|
|
if(m_pExtMgr != NULL) {
|
|
// check if there is any extension which supports this IID
|
|
hr = m_pExtMgr->GetCLSIDForNames(
|
|
rgszNames,
|
|
cNames,
|
|
lcid,
|
|
rgDispId,
|
|
lFlags,
|
|
pCLSID
|
|
);
|
|
if(SUCCEEDED(hr))
|
|
// successfully got the CLSID and DISPIDs
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
// check if the underlying WinNT object supports this name
|
|
hr = m_pUnkInner->QueryInterface(IID_IDispatch, (void **) &pDispatch);
|
|
if(FAILED(hr))
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
hr = pDispatch->GetIDsOfNames(
|
|
IID_NULL,
|
|
rgszNames,
|
|
cNames,
|
|
lcid,
|
|
rgDispId
|
|
);
|
|
if(SUCCEEDED(hr)) {
|
|
pDispatch->Release();
|
|
memcpy(pCLSID, &CLSID_WinNTObject, sizeof(GUID));
|
|
|
|
RRETURN(UMI_S_NO_ERROR);
|
|
}
|
|
|
|
|
|
error:
|
|
|
|
if(pDispatch != NULL)
|
|
pDispatch->Release();
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetContainer
|
|
//
|
|
// Synopsis: Returns a pointer to the IADsContainer interface of the
|
|
// underlying WinNT object. Used as a backdoor to get access to
|
|
// the WinNT object from a UMI object. Implements
|
|
// IUmiADSIPrivate::GetContainer().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// ppContainer Returns pointer to IADsContainer interface on WinNT object
|
|
//
|
|
// Returns: S_OK on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppContainer to return the IADsContainer interface pointer.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::GetContainer(void **ppContainer)
|
|
{
|
|
if(NULL == ppContainer)
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
|
|
*ppContainer = (void *) m_pIADsContainer;
|
|
if(m_pIADsContainer != NULL)
|
|
m_pIADsContainer->AddRef();
|
|
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: CopyTo
|
|
//
|
|
// Synopsis: Creates an uncommitted copy of an object at the location
|
|
// specified by a URL. This is the same as Clone except that
|
|
// the new object has a different path than the old one. If the
|
|
// cache is dirty in teh source object, then the destination will
|
|
// also end up with a dirty cache.
|
|
//
|
|
// Update: This method will not be supported for now.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// uFlags Flags for CopyTo. Must be 0 for now.
|
|
// pURL Destination path (native or UMI)
|
|
// riid Interface requested from new object
|
|
// pCopy Returns interface requested
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: *pCopy to return requested interface pointer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::CopyTo(
|
|
ULONG uFlags,
|
|
IUmiURL *pURL,
|
|
REFIID riid,
|
|
LPVOID *pCopy
|
|
)
|
|
{
|
|
HRESULT hr = UMI_S_NO_ERROR;
|
|
ULONGLONG PathType = 0;
|
|
WCHAR pszUrl[MAX_URL+1];
|
|
WCHAR *pszLongUrl = pszUrl;
|
|
ULONG ulUrlLen = MAX_URL;
|
|
LPWSTR RelName = NULL;
|
|
BSTR bstrClass = NULL;
|
|
IUnknown *pUnkParent = NULL;
|
|
IADsContainer *pIADsCont = NULL;
|
|
IDispatch *pDispatch = NULL;
|
|
IUmiObject *pUmiObj = NULL;
|
|
IUmiADSIPrivate *pUmiPrivate = NULL;
|
|
OBJECTINFO ObjectInfo;
|
|
POBJECTINFO pObjectInfo = NULL;
|
|
CLexer Lexer(NULL);
|
|
DWORD dwNumComponents = 0, dwIndex = 0, dwCoreIndex = 0;
|
|
LPWSTR *ppszClasses = NULL;
|
|
CCoreADsObject *pCoreObj = NULL;
|
|
|
|
SetLastStatus(UMI_E_NOTIMPL);
|
|
RRETURN(UMI_E_NOTIMPL);
|
|
|
|
SetLastStatus(0);
|
|
|
|
if(uFlags != 0)
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_FLAGS);
|
|
|
|
if( (NULL == pCopy) || (NULL == pURL) )
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALIDARG);
|
|
|
|
if( (NULL == m_pCoreObj) || (NULL == m_pIADs) )
|
|
// shouldn't happen, but just being paranoid
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
*pCopy = NULL;
|
|
|
|
// check if this is a native path or UMI path
|
|
hr = pURL->GetPathInfo(0, &PathType);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if(PathType & UMIPATH_INFO_NATIVE_STRING) {
|
|
// Get the native path from the URL
|
|
hr = pURL->Get(0, &ulUrlLen, pszUrl);
|
|
|
|
if(WBEM_E_BUFFER_TOO_SMALL == hr) {
|
|
// need to allocate more memory for URL
|
|
pszLongUrl = (WCHAR *) AllocADsMem(ulUrlLen * sizeof(WCHAR));
|
|
if(NULL == pszLongUrl)
|
|
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
|
|
|
|
hr = pURL->Get(0, &ulUrlLen, pszLongUrl);
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
else {
|
|
// assume UMI path if not native
|
|
hr = UmiToWinNTPath(
|
|
pURL,
|
|
&pszLongUrl,
|
|
&dwNumComponents,
|
|
&ppszClasses
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
// get the native path of the parent and the relative name of new object
|
|
|
|
Lexer.SetBuffer(pszLongUrl);
|
|
pObjectInfo = &ObjectInfo;
|
|
memset(pObjectInfo, 0, sizeof(OBJECTINFO));
|
|
hr = Object(&Lexer, pObjectInfo);
|
|
if(FAILED(hr)) {
|
|
pObjectInfo = NULL; // so we don't attempt to free object info later
|
|
goto error;
|
|
}
|
|
|
|
hr = BuildParent(pObjectInfo, pszLongUrl);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if(pObjectInfo->NumComponents != 0)
|
|
RelName =
|
|
pObjectInfo->DisplayComponentArray[pObjectInfo->NumComponents - 1];
|
|
else
|
|
// can't have a parent for such a path
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
// Decrement number of components since we are dealing with the parent
|
|
dwNumComponents--;
|
|
|
|
hr = GetObject(
|
|
pszLongUrl,
|
|
(LPVOID *) &pUnkParent,
|
|
*m_pCreds
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUnkParent->QueryInterface(
|
|
IID_IUmiADSIPrivate,
|
|
(LPVOID *) &pUmiPrivate
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUmiPrivate->GetCoreObject((void **) &pCoreObj);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// walk the list of classes in reverse order. Reason for reverse order
|
|
// is that the WinNT provider may tack on an additional component to
|
|
// the ADsPath stored in the core object. For example,
|
|
// Open("WinNT://ntdsdc1") would return an ADsPath of
|
|
// "WinNT://ntdev/ntdsdc1".
|
|
|
|
if(dwNumComponents > 0) {
|
|
dwCoreIndex = pCoreObj->_dwNumComponents - 1;
|
|
for(dwIndex = dwNumComponents - 1; ((long) dwIndex) >= 0; dwIndex--) {
|
|
if( _wcsicmp(
|
|
ppszClasses[dwIndex],
|
|
pCoreObj->_CompClasses[dwCoreIndex]) ) {
|
|
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
}
|
|
|
|
dwCoreIndex--;
|
|
}
|
|
}
|
|
|
|
hr = pUmiPrivate->GetContainer((void **) &pIADsCont);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if(NULL == pIADsCont)
|
|
// parent object is not a container
|
|
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
|
|
|
|
// get the class of this object
|
|
hr = m_pIADs->get_Class(&bstrClass);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// make sure that the destination path mentioned the same class
|
|
if(_wcsicmp(bstrClass, ppszClasses[dwNumComponents]))
|
|
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
|
|
|
|
// now Create() the new object
|
|
hr = pIADsCont->Create(
|
|
bstrClass,
|
|
RelName,
|
|
&pDispatch
|
|
);
|
|
if(E_NOTIMPL == hr) // parent is namespace object
|
|
hr = UMI_E_FAIL;
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pDispatch->QueryInterface(IID_IUmiObject, (LPVOID *) &pUmiObj);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// if the source object is bound, refresh it if required
|
|
if(ADS_OBJECT_BOUND == m_pCoreObj->GetObjectState()) {
|
|
// object exists on server
|
|
if(FALSE == m_fRefreshDone) {
|
|
hr = m_pCoreObj->ImplicitGetInfo();
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
// copy over the attributes in the property cache
|
|
hr = CopyPropCache(pUmiObj, (IUmiObject *) this);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pUmiObj->QueryInterface(riid, pCopy);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
error:
|
|
|
|
if( (pszLongUrl != NULL) && (pszLongUrl != pszUrl) )
|
|
FreeADsMem(pszLongUrl);
|
|
|
|
if(bstrClass != NULL)
|
|
SysFreeString(bstrClass);
|
|
|
|
if(pUnkParent != NULL)
|
|
pUnkParent->Release();
|
|
|
|
if(pIADsCont != NULL)
|
|
pIADsCont->Release();
|
|
|
|
if(pUmiObj != NULL)
|
|
pUmiObj->Release();
|
|
|
|
if(pUmiPrivate != NULL)
|
|
pUmiPrivate->Release();
|
|
|
|
if(pDispatch != NULL)
|
|
pDispatch->Release();
|
|
|
|
if(pObjectInfo != NULL)
|
|
FreeObjectInfo(&ObjectInfo, TRUE);
|
|
|
|
if(ppszClasses != NULL) {
|
|
for(dwIndex = 0; dwIndex < dwNumComponents; dwIndex++) {
|
|
if(ppszClasses[dwIndex] != NULL)
|
|
FreeADsStr(ppszClasses[dwIndex]);
|
|
}
|
|
FreeADsMem(ppszClasses);
|
|
}
|
|
|
|
if(FAILED(hr))
|
|
SetLastStatus(hr);
|
|
|
|
RRETURN(MapHrToUmiError(hr));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: GetCoreObject
|
|
//
|
|
// Synopsis: Returns a pointer to the core object of the
|
|
// underlying WinNT object. Used as a backdoor to get access to
|
|
// the WinNT core object from a UMI object. Implements
|
|
// IUmiADSIPrivate::GetCoreObject().
|
|
//
|
|
// Arguments:
|
|
//
|
|
// ppCoreObj Returns pointer to core object of WinNT object
|
|
//
|
|
// Returns: S_OK on success. Error code otherwise.
|
|
//
|
|
// Modifies: *ppCoreObj to return the core object pointer.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP CUmiObject::GetCoreObject(void **ppCoreObj)
|
|
{
|
|
if(NULL == ppCoreObj)
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
|
|
*ppCoreObj = NULL;
|
|
|
|
if(NULL == m_pCoreObj)
|
|
// shouldn't happen. Just being paranoid.
|
|
RRETURN(UMI_E_FAIL);
|
|
|
|
*ppCoreObj = (void *) m_pCoreObj;
|
|
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Function: CheckClasses
|
|
//
|
|
// Synopsis: Checks that the classes specified in the UMI path passed to
|
|
// Move are valid. Need a separate function for this because UMI
|
|
// doesn't actually retrieve the object that is to be moved - it
|
|
// is handled internally within ADSI. So, we need to check the
|
|
// classes before calling into ADSI. We make use of the fact that
|
|
// the WinNT provider only supports moving user and group objects.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// dwNumComponents Number of components in the UMI path
|
|
// ppszClasses Class of each component
|
|
//
|
|
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
|
|
//
|
|
// Modifies: Nothing
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT CUmiObject::CheckClasses(
|
|
DWORD dwNumComponents,
|
|
LPWSTR *ppszClasses
|
|
)
|
|
{
|
|
if(NULL == ppszClasses)
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
|
|
if( (dwNumComponents != 2) && (dwNumComponents != 3) )
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
|
|
// can only move users or groups
|
|
if( _wcsicmp(ppszClasses[dwNumComponents - 1], USER_CLASS_NAME) &&
|
|
_wcsicmp(ppszClasses[dwNumComponents - 1], GROUP_CLASS_NAME) )
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
|
|
if(2 == dwNumComponents) {
|
|
if( _wcsicmp(ppszClasses[0], DOMAIN_CLASS_NAME) &&
|
|
_wcsicmp(ppszClasses[0], COMPUTER_CLASS_NAME) )
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
}
|
|
|
|
if(3 == dwNumComponents) {
|
|
if( _wcsicmp(ppszClasses[0], DOMAIN_CLASS_NAME) ||
|
|
_wcsicmp(ppszClasses[1], COMPUTER_CLASS_NAME) )
|
|
RRETURN(UMI_E_INVALIDARG);
|
|
}
|
|
|
|
RRETURN(S_OK);
|
|
}
|