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.
1049 lines
25 KiB
1049 lines
25 KiB
//---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1995
|
|
//
|
|
// File: cenumdom.cxx
|
|
//
|
|
// Contents: Windows NT 3.5 Domain Enumeration Code
|
|
//
|
|
// CWinNTDomainEnum::CWinNTDomainEnum()
|
|
// CWinNTDomainEnum::CWinNTDomainEnum
|
|
// CWinNTDomainEnum::EnumObjects
|
|
// CWinNTDomainEnum::EnumObjects
|
|
//
|
|
// History:
|
|
//----------------------------------------------------------------------------
|
|
#include "winnt.hxx"
|
|
#pragma hdrstop
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CWinNTEnumVariant::Create
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments: [pCollection]
|
|
// [ppEnumVariant]
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 01-30-95 krishnag Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CWinNTDomainEnum::Create(
|
|
CWinNTDomainEnum FAR* FAR* ppenumvariant,
|
|
LPWSTR ADsPath,
|
|
LPWSTR DomainName,
|
|
VARIANT var,
|
|
CWinNTCredentials& Credentials
|
|
)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
CWinNTDomainEnum FAR* penumvariant = NULL;
|
|
NET_API_STATUS nasStatus = 0;
|
|
|
|
*ppenumvariant = NULL;
|
|
|
|
penumvariant = new CWinNTDomainEnum();
|
|
if (!penumvariant) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
penumvariant->_ADsPath = AllocADsStr( ADsPath);
|
|
if (!penumvariant->_ADsPath) {
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
penumvariant->_DomainName = AllocADsStr( DomainName);
|
|
if (!penumvariant->_DomainName) {
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
hr = ObjectTypeList::CreateObjectTypeList(
|
|
var,
|
|
&penumvariant->_pObjList
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
//
|
|
// ramv's change. You don't need to do a WinNTGetCachedDCName
|
|
// to validate a domain here. You might be dealing with a
|
|
// workgroup. If this call succeeds then we keep a BOOL variable
|
|
// which tells us next time when it is necessary whether it is a
|
|
// domain or workgroup
|
|
//
|
|
|
|
hr = WinNTGetCachedDCName(
|
|
penumvariant->_DomainName,
|
|
penumvariant->_szDomainPDCName,
|
|
Credentials.GetFlags()
|
|
);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
penumvariant->_fIsDomain = TRUE;
|
|
|
|
} else {
|
|
penumvariant->_fIsDomain = FALSE;
|
|
}
|
|
|
|
penumvariant->_Credentials = Credentials;
|
|
hr = penumvariant->_Credentials.RefDomain(DomainName);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
*ppenumvariant = penumvariant;
|
|
|
|
RRETURN(S_OK);
|
|
|
|
error:
|
|
|
|
delete penumvariant;
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
CWinNTDomainEnum::CWinNTDomainEnum():
|
|
_ADsPath(NULL),
|
|
_DomainName(NULL)
|
|
{
|
|
_pObjList = NULL;
|
|
_pBuffer = NULL;
|
|
_dwObjectReturned = 0;
|
|
_dwIndex = 0;
|
|
_dwObjectCurrentEntry = 0;
|
|
_dwObjectTotal = 0;
|
|
_dwNetCount = 0;
|
|
|
|
_hLGroupComputer = NULL;
|
|
_hGGroupComputer = NULL;
|
|
_dwGroupArrayIndex = 0;
|
|
|
|
|
|
_dwCompObjectReturned = 0;
|
|
_dwCompObjectCurrentEntry = 0;
|
|
_dwCompObjectTotal = 0;
|
|
_pCompBuffer = 0;
|
|
_dwCompIndex = 0;
|
|
_pServerInfo = NULL;
|
|
|
|
_fSchemaReturned = FALSE;
|
|
|
|
memset(_szDomainPDCName, 0, sizeof(WCHAR)*MAX_PATH);
|
|
|
|
}
|
|
|
|
|
|
|
|
CWinNTDomainEnum::CWinNTDomainEnum(ObjectTypeList ObjList):
|
|
_ADsPath(NULL),
|
|
_DomainName(NULL)
|
|
{
|
|
_pObjList = NULL;
|
|
_pBuffer = NULL;
|
|
_dwObjectReturned = 0;
|
|
_dwObjectCurrentEntry = 0;
|
|
_dwIndex = 0;
|
|
_dwNetCount = 0;
|
|
|
|
_hLGroupComputer = NULL;
|
|
_hGGroupComputer = NULL;
|
|
_dwGroupArrayIndex = 0;
|
|
|
|
_dwCompObjectReturned = NULL;
|
|
_dwCompObjectCurrentEntry = NULL;
|
|
_dwCompObjectTotal = NULL;
|
|
_dwCompResumeHandle = 0;
|
|
_pCompBuffer = NULL;
|
|
_fIsDomain = FALSE;
|
|
_pServerInfo = NULL;
|
|
|
|
_fSchemaReturned = FALSE;
|
|
|
|
memset(_szDomainPDCName, 0, sizeof(WCHAR)*MAX_PATH);
|
|
|
|
}
|
|
|
|
CWinNTDomainEnum::~CWinNTDomainEnum()
|
|
{
|
|
if (_hLGroupComputer) {
|
|
WinNTCloseComputer(
|
|
_hLGroupComputer
|
|
);
|
|
}
|
|
|
|
if (_hGGroupComputer) {
|
|
WinNTCloseComputer(
|
|
_hGGroupComputer
|
|
);
|
|
}
|
|
|
|
if (_pCompBuffer) {
|
|
|
|
NetApiBufferFree(_pCompBuffer);
|
|
}
|
|
|
|
if (_DomainName) {
|
|
FreeADsStr(_DomainName);
|
|
}
|
|
|
|
if (_ADsPath) {
|
|
FreeADsStr(_ADsPath);
|
|
}
|
|
|
|
if (_pObjList) {
|
|
|
|
delete _pObjList;
|
|
}
|
|
|
|
if (_pBuffer)
|
|
{
|
|
NetApiBufferFree(_pBuffer);
|
|
}
|
|
|
|
if (_pServerInfo)
|
|
{
|
|
NetApiBufferFree(_pServerInfo);
|
|
}
|
|
|
|
}
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumObjects(
|
|
DWORD ObjectType,
|
|
ULONG cElements,
|
|
VARIANT FAR * pvar,
|
|
ULONG FAR * pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG cElementGlobal = 0;
|
|
ULONG cElementLocal = 0;
|
|
|
|
|
|
switch (ObjectType) {
|
|
|
|
case WINNT_COMPUTER_ID:
|
|
hr = EnumComputers(cElements, pvar, pcElementFetched);
|
|
break;
|
|
case WINNT_USER_ID:
|
|
hr = EnumUsers(cElements, pvar, pcElementFetched);
|
|
break;
|
|
|
|
case WINNT_GROUP_ID:
|
|
|
|
//
|
|
// for backward compatabillity, "group" includes "local group" and
|
|
// "global group" during enumeration
|
|
//
|
|
|
|
//
|
|
// enum all the global groups first
|
|
//
|
|
|
|
hr = EnumGlobalGroups(
|
|
cElements,
|
|
pvar,
|
|
&cElementGlobal
|
|
);
|
|
|
|
//
|
|
// enum local groups when there is no more global
|
|
//
|
|
|
|
if (hr == S_FALSE) {
|
|
hr = EnumLocalGroups(
|
|
cElements-cElementGlobal, // we have reduced buffer size!
|
|
pvar+cElementGlobal,
|
|
&cElementLocal
|
|
);
|
|
}
|
|
|
|
//
|
|
// increment instead of just assingment: for consistency with
|
|
// other switch cases
|
|
//
|
|
(*pcElementFetched) += (cElementGlobal+cElementLocal);
|
|
break;
|
|
|
|
case WINNT_LOCALGROUP_ID:
|
|
hr = EnumLocalGroups(cElements, pvar, pcElementFetched);
|
|
break;
|
|
|
|
case WINNT_GLOBALGROUP_ID:
|
|
hr = EnumGlobalGroups(cElements, pvar, pcElementFetched);
|
|
break;
|
|
|
|
case WINNT_SCHEMA_ID:
|
|
hr = EnumSchema(cElements, pvar, pcElementFetched);
|
|
break;
|
|
default:
|
|
RRETURN(S_FALSE);
|
|
}
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumObjects(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
DWORD i;
|
|
ULONG cRequested = 0;
|
|
ULONG cFetchedByPath = 0;
|
|
ULONG cTotalFetched = 0;
|
|
VARIANT FAR* pPathvar = pvar;
|
|
HRESULT hr = S_OK;
|
|
DWORD ObjectType;
|
|
|
|
for (i = 0; i < cElements; i++) {
|
|
VariantInit(&pvar[i]);
|
|
}
|
|
cRequested = cElements;
|
|
|
|
while (SUCCEEDED(_pObjList->GetCurrentObject(&ObjectType)) &&
|
|
((hr = EnumObjects(ObjectType,
|
|
cRequested,
|
|
pPathvar,
|
|
&cFetchedByPath)) == S_FALSE )) {
|
|
|
|
pPathvar += cFetchedByPath;
|
|
cRequested -= cFetchedByPath;
|
|
cTotalFetched += cFetchedByPath;
|
|
|
|
cFetchedByPath = 0;
|
|
|
|
if (FAILED(_pObjList->Next())){
|
|
if (pcElementFetched)
|
|
*pcElementFetched = cTotalFetched;
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
}
|
|
|
|
if (pcElementFetched) {
|
|
*pcElementFetched = cTotalFetched + cFetchedByPath;
|
|
}
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumSchema(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch *pDispatch = NULL;
|
|
|
|
if ( _fSchemaReturned )
|
|
RRETURN(S_FALSE);
|
|
|
|
if ( cElements > 0 )
|
|
{
|
|
hr = CWinNTSchema::CreateSchema(
|
|
_ADsPath,
|
|
TEXT("Schema"),
|
|
ADS_OBJECT_BOUND,
|
|
IID_IDispatch,
|
|
_Credentials,
|
|
(void **)&pDispatch
|
|
);
|
|
|
|
if ( hr == S_OK )
|
|
{
|
|
VariantInit(&pvar[0]);
|
|
pvar[0].vt = VT_DISPATCH;
|
|
pvar[0].pdispVal = pDispatch;
|
|
(*pcElementFetched)++;
|
|
_fSchemaReturned = TRUE;
|
|
}
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumUsers(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch *pDispatch = NULL;
|
|
DWORD i = 0;
|
|
|
|
if(!_fIsDomain){
|
|
RRETURN(S_FALSE);
|
|
}
|
|
while (i < cElements) {
|
|
|
|
hr = GetUserObject(&pDispatch);
|
|
if (hr == S_FALSE) {
|
|
break;
|
|
}
|
|
|
|
VariantInit(&pvar[i]);
|
|
pvar[i].vt = VT_DISPATCH;
|
|
pvar[i].pdispVal = pDispatch;
|
|
(*pcElementFetched)++;
|
|
i++;
|
|
}
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::GetUserObject(
|
|
IDispatch ** ppDispatch
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
NTSTATUS Status;
|
|
PNET_DISPLAY_USER pUserInfo1 = NULL;
|
|
NET_API_STATUS nasStatus = 0;
|
|
DWORD dwResumeHandle = 0;
|
|
|
|
if (!_pBuffer || (_dwObjectCurrentEntry == _dwObjectReturned)) {
|
|
|
|
if (_pBuffer) {
|
|
NetApiBufferFree(_pBuffer);
|
|
_pBuffer = NULL;
|
|
}
|
|
|
|
_dwObjectCurrentEntry = 0;
|
|
_dwObjectReturned = 0;
|
|
|
|
nasStatus = NetQueryDisplayInformation(
|
|
_szDomainPDCName,
|
|
1,
|
|
_dwIndex,
|
|
1024,
|
|
MAX_PREFERRED_LENGTH,
|
|
&_dwObjectReturned,
|
|
(PVOID *)&_pBuffer
|
|
);
|
|
_dwNetCount++;
|
|
|
|
//
|
|
// The following if clause is to handle real errors; anything
|
|
// other than ERROR_SUCCESS and ERROR_MORE_DATA
|
|
//
|
|
|
|
if ((nasStatus != ERROR_SUCCESS) && (nasStatus != ERROR_MORE_DATA)) {
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
//
|
|
// This one is to handle the termination case - Call completed
|
|
// successfully but there is no data to retrieve _pBuffer = NULL
|
|
//
|
|
|
|
if (!_pBuffer) {
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
_dwIndex = (_pBuffer + _dwObjectReturned -1)->usri1_next_index;
|
|
|
|
}
|
|
|
|
//
|
|
// Now send back the current ovbject
|
|
//
|
|
|
|
pUserInfo1 = (PNET_DISPLAY_USER)_pBuffer;
|
|
pUserInfo1 += _dwObjectCurrentEntry;
|
|
|
|
hr = CWinNTUser::CreateUser(
|
|
_ADsPath,
|
|
WINNT_DOMAIN_ID,
|
|
_DomainName,
|
|
NULL,
|
|
pUserInfo1->usri1_name,
|
|
ADS_OBJECT_BOUND,
|
|
&(pUserInfo1->usri1_flags),
|
|
pUserInfo1->usri1_full_name,
|
|
pUserInfo1->usri1_comment,
|
|
NULL,
|
|
IID_IDispatch,
|
|
_Credentials,
|
|
(void **)ppDispatch
|
|
);
|
|
BAIL_IF_ERROR(hr);
|
|
_dwObjectCurrentEntry++;
|
|
|
|
RRETURN(S_OK);
|
|
|
|
cleanup:
|
|
*ppDispatch = NULL;
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumComputers(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch *pDispatch = NULL;
|
|
DWORD i = 0;
|
|
|
|
while (i < cElements) {
|
|
if(_fIsDomain == TRUE){
|
|
hr = GetComputerObject(&pDispatch);
|
|
}
|
|
else {
|
|
hr = GetComputerObjectInWorkGroup(&pDispatch);
|
|
}
|
|
|
|
if (hr == S_FALSE) {
|
|
break;
|
|
}
|
|
|
|
VariantInit(&pvar[i]);
|
|
pvar[i].vt = VT_DISPATCH;
|
|
pvar[i].pdispVal = pDispatch;
|
|
(*pcElementFetched)++;
|
|
i++;
|
|
}
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::GetComputerObject(
|
|
IDispatch ** ppDispatch
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
NTSTATUS Status;
|
|
PNET_DISPLAY_MACHINE pDisplayComp = NULL;
|
|
NET_API_STATUS nasStatus = 0;
|
|
DWORD dwResumeHandle = 0;
|
|
DWORD clen = 0;
|
|
|
|
if (!_pCompBuffer || (_dwCompObjectCurrentEntry == _dwCompObjectReturned)) {
|
|
|
|
if (_pCompBuffer) {
|
|
NetApiBufferFree(_pCompBuffer);
|
|
_pCompBuffer = NULL;
|
|
}
|
|
|
|
_dwCompObjectCurrentEntry = 0;
|
|
_dwCompObjectReturned = 0;
|
|
|
|
|
|
nasStatus = NetQueryDisplayInformation(
|
|
_szDomainPDCName,
|
|
2,
|
|
_dwCompIndex,
|
|
100,
|
|
MAX_PREFERRED_LENGTH,
|
|
&_dwCompObjectReturned,
|
|
(PVOID *)&_pCompBuffer
|
|
);
|
|
|
|
// The following if clause is to handle real errors; anything
|
|
// other than ERROR_SUCCESS and ERROR_MORE_DATA
|
|
//
|
|
|
|
if ((nasStatus != ERROR_SUCCESS) && (nasStatus != ERROR_MORE_DATA)) {
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
//
|
|
// This one is to handle the termination case - Call completed
|
|
// successfully but there is no data to retrieve _pBuffer = NULL
|
|
//
|
|
|
|
if (!_pCompBuffer) {
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
_dwCompIndex = (_pCompBuffer + _dwCompObjectReturned -1)->usri2_next_index;
|
|
|
|
}
|
|
|
|
//
|
|
// Now send back the current object
|
|
//
|
|
|
|
pDisplayComp = (PNET_DISPLAY_MACHINE)_pCompBuffer;
|
|
pDisplayComp += _dwCompObjectCurrentEntry;
|
|
|
|
//
|
|
// The usri2_name is going to be returned back with a
|
|
// $ character appended. Null set the $ character.
|
|
//
|
|
|
|
clen = wcslen(pDisplayComp->usri2_name);
|
|
*(pDisplayComp->usri2_name + clen -1) = L'\0';
|
|
|
|
hr = CWinNTComputer::CreateComputer(
|
|
_ADsPath,
|
|
_DomainName,
|
|
pDisplayComp->usri2_name,
|
|
ADS_OBJECT_BOUND,
|
|
IID_IDispatch,
|
|
_Credentials,
|
|
(void **)ppDispatch
|
|
);
|
|
BAIL_IF_ERROR(hr);
|
|
_dwCompObjectCurrentEntry++;
|
|
|
|
RRETURN(S_OK);
|
|
|
|
cleanup:
|
|
*ppDispatch = NULL;
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CWinNTDomainEnum::Next
|
|
//
|
|
// Synopsis: Returns cElements number of requested NetOle objects in the
|
|
// array supplied in pvar.
|
|
//
|
|
// Arguments: [cElements] -- The number of elements requested by client
|
|
// [pvar] -- ptr to array of VARIANTs to for return objects
|
|
// [pcElementFetched] -- if non-NULL, then number of elements
|
|
// -- actually returned is placed here
|
|
//
|
|
// Returns: HRESULT -- S_OK if number of elements requested are returned
|
|
// -- S_FALSE if number of elements is < requested
|
|
//
|
|
// Modifies:
|
|
//
|
|
// History: 11-3-95 krishnag Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CWinNTDomainEnum::Next(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
ULONG cElementFetched = 0;
|
|
HRESULT hr = S_OK;
|
|
|
|
if (NULL == pvar)
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
hr = EnumObjects(
|
|
cElements,
|
|
pvar,
|
|
&cElementFetched
|
|
);
|
|
}
|
|
|
|
if (pcElementFetched) {
|
|
*pcElementFetched = cElementFetched;
|
|
}
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::GetComputerObjectInWorkGroup(
|
|
IDispatch ** ppDispatch
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
NTSTATUS Status;
|
|
PSERVER_INFO_100 pServerInfo = NULL;
|
|
NET_API_STATUS nasStatus = 0;
|
|
DWORD clen = 0;
|
|
|
|
if (!_pServerInfo || (_dwCompObjectCurrentEntry == _dwCompObjectReturned))
|
|
{
|
|
|
|
if (_pServerInfo) {
|
|
NetApiBufferFree(_pServerInfo);
|
|
_pServerInfo = NULL;
|
|
}
|
|
|
|
if(_dwCompObjectTotal == _dwCompObjectReturned
|
|
&& (_dwCompObjectTotal !=0)){
|
|
//
|
|
// we got all elements already, no need to do another call
|
|
//
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
nasStatus = NetServerEnum(
|
|
NULL,
|
|
100,
|
|
(LPBYTE *)&_pServerInfo,
|
|
MAX_PREFERRED_LENGTH,
|
|
&_dwCompObjectReturned,
|
|
&_dwCompObjectTotal,
|
|
SV_TYPE_NT,
|
|
_DomainName,
|
|
&_dwCompResumeHandle
|
|
);
|
|
|
|
/*
|
|
nasStatus = NetQueryDisplayInformation(
|
|
_szDomainPDCName,
|
|
2,
|
|
_dwCompIndex,
|
|
100,
|
|
MAX_PREFERRED_LENGTH,
|
|
&_dwCompObjectReturned,
|
|
(PVOID *)&_pServerInfo
|
|
);
|
|
|
|
*/
|
|
//
|
|
// The following if clause is to handle real errors; anything
|
|
// other than ERROR_SUCCESS and ERROR_MORE_DATA
|
|
//
|
|
|
|
if ((nasStatus != ERROR_SUCCESS) && (nasStatus != ERROR_MORE_DATA)) {
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
_dwCompObjectCurrentEntry = 0;
|
|
|
|
//
|
|
// This one is to handle the termination case - Call completed
|
|
// successfully but there is no data to retrieve _pServerInfo = NULL
|
|
//
|
|
|
|
if (!_dwCompObjectReturned) {
|
|
_pServerInfo = NULL;
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Now send back the current object
|
|
//
|
|
|
|
pServerInfo = (PSERVER_INFO_100)_pServerInfo;
|
|
pServerInfo += _dwCompObjectCurrentEntry;
|
|
|
|
hr = CWinNTComputer::CreateComputer(
|
|
_ADsPath,
|
|
_DomainName,
|
|
pServerInfo->sv100_name,
|
|
ADS_OBJECT_BOUND,
|
|
IID_IDispatch,
|
|
_Credentials,
|
|
(void **)ppDispatch
|
|
);
|
|
BAIL_IF_ERROR(hr);
|
|
_dwCompObjectCurrentEntry++;
|
|
|
|
RRETURN(S_OK);
|
|
|
|
cleanup:
|
|
*ppDispatch = NULL;
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::GetGlobalGroupObject(
|
|
IDispatch ** ppDispatch
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPWINNT_GROUP pWinNTGrp = NULL;
|
|
LPBYTE pBuffer = NULL;
|
|
DWORD dwReturned = 0;
|
|
BOOL dwRet = 0;
|
|
|
|
|
|
|
|
if (!_hGGroupComputer) {
|
|
dwRet = WinNTComputerOpen(
|
|
_DomainName,
|
|
(_szDomainPDCName + 2),
|
|
WINNT_DOMAIN_ID,
|
|
&_hGGroupComputer
|
|
);
|
|
if (!dwRet) {
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
dwRet = WinNTEnumGlobalGroups(
|
|
_hGGroupComputer,
|
|
1,
|
|
&pBuffer,
|
|
&dwReturned
|
|
);
|
|
if (!dwRet) {
|
|
goto error;
|
|
}
|
|
|
|
pWinNTGrp = (LPWINNT_GROUP)pBuffer;
|
|
|
|
hr = CWinNTGroup::CreateGroup(
|
|
pWinNTGrp->Parent,
|
|
WINNT_DOMAIN_ID,
|
|
pWinNTGrp->Domain,
|
|
pWinNTGrp->Computer,
|
|
pWinNTGrp->Name,
|
|
WINNT_GROUP_GLOBAL,
|
|
ADS_OBJECT_BOUND,
|
|
IID_IDispatch,
|
|
_Credentials,
|
|
(void **)ppDispatch
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = S_OK;
|
|
|
|
cleanup:
|
|
|
|
if (pBuffer) {
|
|
|
|
FreeADsMem(pBuffer);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
|
|
error:
|
|
*ppDispatch = NULL;
|
|
|
|
|
|
hr = S_FALSE;
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::GetLocalGroupObject(
|
|
IDispatch ** ppDispatch
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPWINNT_GROUP pWinNTGrp = NULL;
|
|
LPBYTE pBuffer = NULL;
|
|
DWORD dwReturned = 0;
|
|
BOOL dwRet = 0;
|
|
|
|
|
|
|
|
if (!_hLGroupComputer) {
|
|
dwRet = WinNTComputerOpen(
|
|
_DomainName,
|
|
(_szDomainPDCName + 2),
|
|
WINNT_DOMAIN_ID,
|
|
&_hLGroupComputer
|
|
);
|
|
if (!dwRet) {
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
dwRet = WinNTEnumLocalGroups(
|
|
_hLGroupComputer,
|
|
1,
|
|
&pBuffer,
|
|
&dwReturned
|
|
);
|
|
if (!dwRet) {
|
|
goto error;
|
|
}
|
|
|
|
pWinNTGrp = (LPWINNT_GROUP)pBuffer;
|
|
|
|
hr = CWinNTGroup::CreateGroup(
|
|
pWinNTGrp->Parent,
|
|
WINNT_DOMAIN_ID,
|
|
pWinNTGrp->Domain,
|
|
pWinNTGrp->Computer,
|
|
pWinNTGrp->Name,
|
|
WINNT_GROUP_LOCAL,
|
|
ADS_OBJECT_BOUND,
|
|
IID_IDispatch,
|
|
_Credentials,
|
|
(void **)ppDispatch
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = S_OK;
|
|
|
|
cleanup:
|
|
|
|
if (pBuffer) {
|
|
|
|
FreeADsMem(pBuffer);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
|
|
error:
|
|
*ppDispatch = NULL;
|
|
|
|
|
|
hr = S_FALSE;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumGroupObjects(
|
|
DWORD ObjectType,
|
|
ULONG cElements,
|
|
VARIANT FAR * pvar,
|
|
ULONG FAR * pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
switch (ObjectType) {
|
|
|
|
case WINNT_GROUP_GLOBAL:
|
|
hr = EnumGlobalGroups(cElements, pvar, pcElementFetched);
|
|
break;
|
|
|
|
case WINNT_GROUP_LOCAL:
|
|
hr = EnumLocalGroups(cElements, pvar, pcElementFetched);
|
|
break;
|
|
|
|
default:
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
RRETURN(hr);
|
|
}
|
|
|
|
|
|
ULONG GroupTypeArray[] = {WINNT_GROUP_GLOBAL, WINNT_GROUP_LOCAL, 0xFFFFFFFF};
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumGroups(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
DWORD i;
|
|
ULONG cRequested = 0;
|
|
ULONG cFetchedByPath = 0;
|
|
ULONG cTotalFetched = 0;
|
|
VARIANT FAR* pPathvar = pvar;
|
|
HRESULT hr = S_OK;
|
|
DWORD ObjectType;
|
|
|
|
if(!_fIsDomain){
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
for (i = 0; i < cElements; i++) {
|
|
VariantInit(&pvar[i]);
|
|
}
|
|
cRequested = cElements;
|
|
|
|
while ((GroupTypeArray[_dwGroupArrayIndex] != (ULONG)-1) &&
|
|
((hr = EnumGroupObjects(
|
|
GroupTypeArray[_dwGroupArrayIndex],
|
|
cRequested,
|
|
pPathvar,
|
|
&cFetchedByPath)) == S_FALSE )) {
|
|
|
|
pPathvar += cFetchedByPath;
|
|
cRequested -= cFetchedByPath;
|
|
cTotalFetched += cFetchedByPath;
|
|
|
|
cFetchedByPath = 0;
|
|
|
|
if (GroupTypeArray[_dwGroupArrayIndex++] == (ULONG)-1){
|
|
if (pcElementFetched)
|
|
*pcElementFetched = cTotalFetched;
|
|
RRETURN(S_FALSE);
|
|
}
|
|
|
|
}
|
|
|
|
if (pcElementFetched) {
|
|
*pcElementFetched = cTotalFetched + cFetchedByPath;
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumGlobalGroups(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch *pDispatch = NULL;
|
|
DWORD i = 0;
|
|
|
|
while (i < cElements) {
|
|
|
|
hr = GetGlobalGroupObject(&pDispatch);
|
|
if (hr == S_FALSE) {
|
|
break;
|
|
}
|
|
|
|
VariantInit(&pvar[i]);
|
|
pvar[i].vt = VT_DISPATCH;
|
|
pvar[i].pdispVal = pDispatch;
|
|
(*pcElementFetched)++;
|
|
i++;
|
|
}
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWinNTDomainEnum::EnumLocalGroups(
|
|
ULONG cElements,
|
|
VARIANT FAR* pvar,
|
|
ULONG FAR* pcElementFetched
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IDispatch *pDispatch = NULL;
|
|
DWORD i = 0;
|
|
|
|
while (i < cElements) {
|
|
|
|
hr = GetLocalGroupObject(&pDispatch);
|
|
if (hr == S_FALSE) {
|
|
break;
|
|
}
|
|
|
|
VariantInit(&pvar[i]);
|
|
pvar[i].vt = VT_DISPATCH;
|
|
pvar[i].pdispVal = pDispatch;
|
|
(*pcElementFetched)++;
|
|
i++;
|
|
}
|
|
return(hr);
|
|
}
|