archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
7 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: 1b390dddff
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1b390dddff'
${ noResults }
windows-xp/Source/XPSP1/NT/ds/adsi/winnt/cumiconn.cxx

903 lines
26 KiB
Raw Blame History

//----------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: cumiconn.cxx
//
// Contents: Contains the UMI connection object implementation
//
// History: 03-02-00 SivaramR Created.
//
//----------------------------------------------------------------------------
#include "winnt.hxx"
//----------------------------------------------------------------------------
// Function: CreateConnection
//
// Synopsis: Creates a connection object. Called by class factory.
//
// Arguments:
//
// iid Interface requested. Only interface supported is IUmiConnection.
// ppInterface Returns pointer to interface requested
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: *ppInterface to return a pointer to the interface requested
//
//----------------------------------------------------------------------------
HRESULT CUmiConnection::CreateConnection(
REFIID iid,
LPVOID *ppInterface
)
{
CUmiConnection *pConn = NULL;
HRESULT hr = S_OK;
ADsAssert(ppInterface);
pConn = new CUmiConnection();
if(NULL == pConn)
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
// initialize connection object
hr = pConn->FInit();
BAIL_ON_FAILURE(hr);
hr = pConn->QueryInterface(iid, ppInterface);
BAIL_ON_FAILURE(hr);
pConn->Release();
RRETURN(S_OK);
error:
if(pConn != NULL)
delete pConn;
RRETURN(hr);
}
//----------------------------------------------------------------------------
// Function: CUmiConnection
//
// Synopsis: Constructor. Initializes all member variables
//
// Arguments:
//
// None
//
// Returns: Nothing.
//
// Modifies: Nothing.
//
//----------------------------------------------------------------------------
CUmiConnection::CUmiConnection(void)
{
m_pIUmiPropList = NULL;
m_pCUmiPropList = NULL;
m_ulErrorStatus = 0;
m_pIADsOpenDSObj = NULL;
m_fAlreadyOpened = FALSE;
m_pszComputerName = NULL;
m_pszDomainName = NULL;
}
//----------------------------------------------------------------------------
// Function: ~CUmiConnection
//
// Synopsis: Destructor. Frees member variables
//
// Arguments:
//
// None
//
// Returns: Nothing.
//
// Modifies: Nothing.
//
//----------------------------------------------------------------------------
CUmiConnection::~CUmiConnection(void)
{
if(m_pIUmiPropList != NULL)
m_pIUmiPropList->Release();
if(m_pszComputerName != NULL)
FreeADsStr(m_pszComputerName);
if(m_pszDomainName != NULL)
FreeADsStr(m_pszDomainName);
if(m_pIADsOpenDSObj != NULL)
m_pIADsOpenDSObj->Release();
// m_pCUmiPropList does not have to be deleted since the Release() above
// has already done it.
}
//----------------------------------------------------------------------------
// Function: FInit
//
// Synopsis: Initializes connection object.
//
// Arguments:
//
// None
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: Nothing.
//
//----------------------------------------------------------------------------
HRESULT CUmiConnection::FInit(void)
{
HRESULT hr = S_OK;
CUmiPropList *pPropList = NULL;
pPropList = new CUmiPropList(ConnectionClass, g_dwConnectionTableSize);
if(NULL == pPropList)
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
hr = pPropList->FInit(NULL, g_UmiConUnImplProps);
BAIL_ON_FAILURE(hr);
hr = pPropList->QueryInterface(
IID_IUmiPropList,
(void **) &m_pIUmiPropList
);
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.
pPropList->Release();
m_pCUmiPropList = pPropList;
hr = m_pCUmiPropList->SetDefaultConnProps();
BAIL_ON_FAILURE(hr);
RRETURN(S_OK);
error:
if(m_pIUmiPropList != NULL) {
m_pIUmiPropList->Release();
m_pIUmiPropList = NULL;
m_pCUmiPropList = NULL;
}
else if(pPropList != NULL)
delete pPropList;
RRETURN(hr);
}
//----------------------------------------------------------------------------
// Function: QueryInterface
//
// Synopsis: Queries connection object for supported interfaces. Only
// IUmiConnection is supported.
//
// 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 CUmiConnection::QueryInterface(
REFIID iid,
LPVOID *ppInterface
)
{
if(NULL == ppInterface)
RRETURN(E_INVALIDARG);
*ppInterface = NULL;
if(IsEqualIID(iid, IID_IUnknown))
*ppInterface = (IUmiConnection *) this;
else if(IsEqualIID(iid, IID_IUmiConnection))
*ppInterface = (IUmiConnection *) this;
else if(IsEqualIID(iid, IID_IUmiBaseObject))
*ppInterface = (IUmiBaseObject *) this;
else if(IsEqualIID(iid, IID_IUmiPropList))
*ppInterface = (IUmiPropList *) this;
else
RRETURN(E_NOINTERFACE);
AddRef();
RRETURN(S_OK);
}
//----------------------------------------------------------------------------
// 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.
//
//----------------------------------------------------------------------------
STDMETHODIMP CUmiConnection::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: 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
//
//----------------------------------------------------------------------------
STDMETHODIMP CUmiConnection::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_pIUmiPropList != NULL);
hr = m_pIUmiPropList->QueryInterface(IID_IUmiPropList, (void **)pPropList);
error:
if(FAILED(hr))
SetLastStatus(hr);
RRETURN(MapHrToUmiError(hr));
}
//----------------------------------------------------------------------------
// Function: SetLastStatus
//
// Synopsis: Sets the status of the last operation.
//
// Arguments:
//
// ulStatus Status to be set
//
// Returns: Nothing
//
// Modifies: Nothing
//
//----------------------------------------------------------------------------
void CUmiConnection::SetLastStatus(ULONG ulStatus)
{
m_ulErrorStatus = ulStatus;
return;
}
//----------------------------------------------------------------------------
// Function: Open
//
// Synopsis: Opens the object specified by a URL and gets the interface
// requested on this object. Implements IUmiConnection::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 CUmiConnection::Open(
IUmiURL *pURL,
ULONG uFlags,
REFIID TargetIID,
LPVOID *ppInterface
)
{
HRESULT hr = UMI_S_NO_ERROR;
LPWSTR pszUserName = NULL, pszPassword = NULL;
DWORD dwBindFlags = 0, dwNumComponents = 0, dwIndex = 0;
LPWSTR *ppszClasses = NULL;
WCHAR pszUrl[MAX_URL+1];
WCHAR *pszLongUrl = pszUrl;
ULONG ulUrlLen = MAX_URL;
IUnknown *pIUnknown = NULL;
CWinNTNamespaceCF tmpNamCF;
ULONGLONG PathType = 0;
BOOL fPrevAlreadyOpened = FALSE;
LPWSTR pszPrevComputer = NULL, pszPrevDomain = 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);
*ppInterface = NULL;
// Check if the user specified any interface properties for authentication
hr = GetUserName(&pszUserName);
BAIL_ON_FAILURE(hr);
hr = GetPassword(&pszPassword);
BAIL_ON_FAILURE(hr);
hr = GetBindFlags(&dwBindFlags);
BAIL_ON_FAILURE(hr);
// 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);
}
hr = tmpNamCF.CreateInstance(
NULL,
IID_IADsOpenDSObject,
(void **) &m_pIADsOpenDSObj
);
BAIL_ON_FAILURE(hr);
//
// we need a way to distinguish between calls to OpenDSObject from UMI
// vs ADSI. We use the bind flags for this purpose. If ADS_AUTH_RESERVED
// is set, then the call is from UMI. ADSI clients are not allowed to use
// this flag - OLEDB relies on this.
//
hr = m_pIADsOpenDSObj->OpenDSObject(
pszLongUrl,
pszUserName,
pszPassword,
dwBindFlags | ADS_AUTH_RESERVED,
(IDispatch **) &pIUnknown
);
BAIL_ON_FAILURE(hr);
// save off state in case we need to restore it later
fPrevAlreadyOpened = m_fAlreadyOpened;
pszPrevComputer = m_pszComputerName;
pszPrevDomain = m_pszDomainName;
// ensure that the returned object is what the user requested and that the
// object is on the same domain/server that this connection is for
hr = CheckObject(
pIUnknown,
dwNumComponents,
ppszClasses
);
BAIL_ON_FAILURE(hr);
hr = pIUnknown->QueryInterface(
TargetIID,
ppInterface
);
if(FAILED(hr)) {
// restore state of connection
m_fAlreadyOpened = fPrevAlreadyOpened;
if(m_pszComputerName != pszPrevComputer) {
if(m_pszComputerName != NULL)
FreeADsStr(m_pszComputerName);
m_pszComputerName = pszPrevComputer;
}
if(m_pszDomainName != pszPrevDomain) {
if(m_pszDomainName != NULL)
FreeADsStr(m_pszDomainName);
m_pszDomainName = pszPrevDomain;
}
goto error;
}
// make interface properties read-only
m_pCUmiPropList->DisableWrites();
error:
if(pszUserName != NULL)
FreeADsMem(pszUserName);
if(pszPassword != NULL)
FreeADsMem(pszPassword);
if(pIUnknown != NULL)
pIUnknown->Release();
if( (pszLongUrl != NULL) && (pszLongUrl != pszUrl) )
FreeADsMem(pszLongUrl);
if(ppszClasses != NULL) {
for(dwIndex = 0; dwIndex < dwNumComponents; dwIndex++) {
if(ppszClasses[dwIndex] != NULL)
FreeADsStr(ppszClasses[dwIndex]);
}
FreeADsMem(ppszClasses);
}
if(FAILED(hr)) {
SetLastStatus(hr);
if(m_pIADsOpenDSObj != NULL) {
m_pIADsOpenDSObj->Release();
m_pIADsOpenDSObj = NULL;
}
}
RRETURN(MapHrToUmiError(hr));
}
//----------------------------------------------------------------------------
// Function: GetUserName
//
// Synopsis: Gets the username from the interface property cache. If the
// interface property was not set, the default username is
// returned.
//
// Arguments:
//
// ppszUserName Returns pointer to the username
//
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies: *ppszUserName to return the username.
//
//----------------------------------------------------------------------------
HRESULT CUmiConnection::GetUserName(LPWSTR *ppszUserName)
{
HRESULT hr = UMI_S_NO_ERROR;
UMI_PROPERTY_VALUES *pUmiProp = NULL;
LPWSTR pszUserName = NULL;
ADsAssert(ppszUserName != NULL);
*ppszUserName = NULL;
hr = m_pIUmiPropList->Get(
TEXT(CONN_INTF_PROP_USERNAME),
0,
&pUmiProp
);
if(FAILED(hr)) {
// shouldn't happen
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
}
ADsAssert(UMI_TYPE_LPWSTR == pUmiProp->pPropArray->uType);
ADsAssert(pUmiProp->pPropArray->pUmiValue != NULL);
pszUserName = pUmiProp->pPropArray->pUmiValue->pszStrValue[0];
if(pszUserName != NULL) {
*ppszUserName = AllocADsStr(pszUserName);
if(NULL == *ppszUserName)
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
else
*ppszUserName = NULL;
error:
if(pUmiProp != NULL)
m_pIUmiPropList->FreeMemory(0, pUmiProp); // ignore error return
RRETURN(hr);
}
//----------------------------------------------------------------------------
// Function: GetPassword
//
// Synopsis: Gets the password from the interface property cache. If the
// interface property was not set, the default password is
// returned.
//
// Arguments:
//
// ppszPassword Returns pointer to the password
//
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies: *ppszPassword to return the password.
//
//----------------------------------------------------------------------------
HRESULT CUmiConnection::GetPassword(LPWSTR *ppszPassword)
{
HRESULT hr = UMI_S_NO_ERROR;
UMI_PROPERTY_VALUES *pUmiProp = NULL;
LPWSTR pszPassword = NULL;
ADsAssert(ppszPassword != NULL);
*ppszPassword = NULL;
hr = m_pCUmiPropList->GetHelper(
TEXT(CONN_INTF_PROP_PASSWORD),
0,
&pUmiProp,
UMI_TYPE_NULL, // no-op
TRUE // this is an internal call to GetHelper
);
if(FAILED(hr)) {
// shouldn't happen
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
}
ADsAssert(UMI_TYPE_LPWSTR == pUmiProp->pPropArray->uType);
ADsAssert(pUmiProp->pPropArray->pUmiValue != NULL);
pszPassword = pUmiProp->pPropArray->pUmiValue->pszStrValue[0];
if(pszPassword != NULL) {
*ppszPassword = AllocADsStr(pszPassword);
if(NULL == *ppszPassword)
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
else
*ppszPassword = NULL;
error:
if(pUmiProp != NULL)
m_pCUmiPropList->FreeMemory(0, pUmiProp); // ignore error return
RRETURN(hr);
}
//----------------------------------------------------------------------------
// Function: GetBindFlags
//
// Synopsis: Gets the bind flags from the interface property cache. If the
// interface properties were not set, the default bind flags are
// returned.
//
// Arguments:
//
// pdwBindFlags Returns the bind flags.
//
// Returns: UMI_S_NO_ERROR on success. Error code otherwise.
//
// Modifies: *pdwBindFlags to return the bind flags.
//
//----------------------------------------------------------------------------
HRESULT CUmiConnection::GetBindFlags(DWORD *pdwBindFlags)
{
HRESULT hr = UMI_S_NO_ERROR;
UMI_PROPERTY_VALUES *pUmiProp = NULL;
DWORD dwUmiBindFlags = 0;
ADsAssert(pdwBindFlags != NULL);
hr = m_pIUmiPropList->Get(
TEXT(CONN_INTF_PROP_SECURE_AUTH),
0,
&pUmiProp
);
if(SUCCEEDED(hr)) {
ADsAssert(UMI_TYPE_BOOL == pUmiProp->pPropArray->uType);
ADsAssert(pUmiProp->pPropArray->pUmiValue != NULL);
if(TRUE == pUmiProp->pPropArray->pUmiValue->bValue[0])
dwUmiBindFlags |= ADS_SECURE_AUTHENTICATION;
m_pIUmiPropList->FreeMemory(0, pUmiProp); // ignore error return
pUmiProp = NULL;
}
else
// shouldn't happen
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
hr = m_pIUmiPropList->Get(
TEXT(CONN_INTF_PROP_READONLY_SERVER),
0,
&pUmiProp
);
if(SUCCEEDED(hr)) {
ADsAssert(UMI_TYPE_BOOL == pUmiProp->pPropArray->uType);
ADsAssert(pUmiProp->pPropArray->pUmiValue != NULL);
if(TRUE == pUmiProp->pPropArray->pUmiValue->bValue[0])
dwUmiBindFlags |= ADS_READONLY_SERVER;
m_pIUmiPropList->FreeMemory(0, pUmiProp); // ignore error return
pUmiProp = NULL;
}
else
// shouldn't happen
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
*pdwBindFlags = dwUmiBindFlags;
error:
if(pUmiProp != NULL)
m_pIUmiPropList->FreeMemory(0, pUmiProp); // ignore error return
RRETURN(hr);
}
//----------------------------------------------------------------------------
// Function: CheckObject
//
// Synopsis: Checks that the returned object is the same as what the user
// requested, if the user passed in a UMI path i.e the classes
// of the components in the UMI path to the object retrieved
// should be the same as what the user requested.
// This function also checks to make sure that subsequent calls to
// Open(), after the first call, specify the same server/domain
// as the first call. If the path used in the first call to Open()
// specifies only a domain name, then all subsequent Open() calls
// should also specify only a domain name and no computer name.
// If the first call to Open() specified only a computer name, then
// all subsequent calls should specify the same computer name. If
// the first call to Open specified the WinNT namespace path
// (umi:///winnt or WinNT:), then subsequent Open() calls can
// connect to any domain/computer. Also, the namespace object can
// be opened successfully even if we already connected to a
// computer/domain.
//
// Arguments:
//
// pUnknown Pointer to the IUnknown of object retrieved
// dwNumComps Number of components if the path is a UMI path. 0 otherwise.
// ppszClasses Array containing the class of each component, if the path is
// a UMI path to an object other than the namespace obejct.
// NULL otherwise.
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: Nothing
//
//----------------------------------------------------------------------------
HRESULT CUmiConnection::CheckObject(
IUnknown *pUnknown,
DWORD dwNumComps,
LPWSTR *ppszClasses
)
{
HRESULT hr = S_OK;
IUmiADSIPrivate *pUmiPrivate = NULL;
CCoreADsObject *pCoreObj = NULL;
LPWSTR pszComputerName = NULL, pszDomainName = NULL;
DWORD dwIndex = 0, dwCoreIndex = 0;
ADsAssert(pUnknown != NULL);
hr = pUnknown->QueryInterface(
IID_IUmiADSIPrivate,
(LPVOID *) &pUmiPrivate
);
BAIL_ON_FAILURE(hr);
hr = pUmiPrivate->GetCoreObject((void **) &pCoreObj);
BAIL_ON_FAILURE(hr);
if(ppszClasses != NULL) {
// user specified a UMI path and it was not umi:///winnt. Make sure the
// classes are the same, as mentioned above.
// 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".
dwCoreIndex = pCoreObj->_dwNumComponents - 1;
for(dwIndex = dwNumComps - 1; ((long) dwIndex) >= 0; dwIndex--) {
if( _wcsicmp(
ppszClasses[dwIndex],
pCoreObj->_CompClasses[dwCoreIndex]) ) {
if( (0 == dwIndex) && (dwNumComps > 1) ) {
if(0 == _wcsicmp(pCoreObj->_CompClasses[1],
SCHEMA_CLASS_NAME)) {
// if the first component of a schema path doesn't match,
// make sure it is "Domain". Need this special case because
// of a bug in the WinNT provider. First component of a
// schema path is ignored and hence the UMI path always
// returns "Computer" as the class for this component. This
// special case allows binding using a path like
// umi://winnt/domain=ntdev/schema=schema.
if(0 == _wcsicmp(ppszClasses[dwIndex],
DOMAIN_CLASS_NAME)) {
dwCoreIndex--;
continue;
}
}
}
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
}
dwCoreIndex--;
}
} // if(ppszClasses...)
// get the domain/computer name specified in the path
if(pCoreObj->_dwNumComponents > 0) {
for(dwIndex = pCoreObj->_dwNumComponents - 1; ((long) dwIndex) >= 0;
dwIndex--) {
if(0 == (_wcsicmp(
pCoreObj->_CompClasses[dwIndex],
SCHEMA_CLASS_NAME)) ) {
// schema container is a special case. We can connect to the
// schema on any computer/domain irrespective of where we are
// connected currently. This is to allow for CIMOM to connect to
// the schema container for a computer. Currently, the WinNT
// provider returns WinNT://ntdev/schema as the schema path on the
// object WinNT://ntdsdc1. Hence we need to allow CIMOM to connect
// to ntdev even after connecting to ntdsdc1.
break; // pszComputerName and pszDomainName are both NULL
}
if(0 == (_wcsicmp(
pCoreObj->_CompClasses[dwIndex],
COMPUTER_CLASS_NAME)) ) {
pszComputerName =
pCoreObj->_ObjectInfo.DisplayComponentArray[dwIndex];
break;
}
else if(0 == (_wcsicmp(
pCoreObj->_CompClasses[dwIndex],
DOMAIN_CLASS_NAME)) ) {
pszDomainName =
pCoreObj->_ObjectInfo.DisplayComponentArray[dwIndex];
break;
}
} // for(..)
} // if(pCoreObj...)
if(FALSE == m_fAlreadyOpened) {
// first call to Open()
if(pszComputerName != NULL) {
m_pszComputerName = AllocADsStr(pszComputerName);
if(NULL == m_pszComputerName) {
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
}
else if(pszDomainName != NULL) {
m_pszDomainName = AllocADsStr(pszDomainName);
if(NULL == m_pszDomainName) {
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
}
m_fAlreadyOpened = TRUE;
}
else if( (pszComputerName != NULL) || (pszDomainName != NULL) ) {
// Already opened connection and this is not the namespace object.
// Make sure that the domain/computer is same as before.
if(m_pszComputerName != NULL) {
if( (NULL == pszComputerName) ||
(_wcsicmp(m_pszComputerName, pszComputerName)) ) {
BAIL_ON_FAILURE(hr = UMI_E_MISMATCHED_SERVER);
}
}
else if(m_pszDomainName != NULL) {
if( (NULL == pszDomainName) ||
(_wcsicmp(m_pszDomainName, pszDomainName)) ) {
BAIL_ON_FAILURE(hr = UMI_E_MISMATCHED_DOMAIN);
}
}
else {
// both m_pszComputerName and m_pszDomainName are NULL. Previous
// open() must have been for a namespace object.
if(pszComputerName != NULL) {
m_pszComputerName = AllocADsStr(pszComputerName);
if(NULL == m_pszComputerName) {
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
}
else if(pszDomainName != NULL) {
m_pszDomainName = AllocADsStr(pszDomainName);
if(NULL == m_pszDomainName) {
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
}
} // else {
} // else if(pszComputer...)
error:
if(pUmiPrivate != NULL)
pUmiPrivate->Release();
RRETURN(hr);
}