able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/netapi/netdom/query.cxx

2368 lines
67 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Microsoft Windows
Copyright (C) Microsoft Corporation, 1998 - 2001
Module Name:
query.c
Abstract:
Handles the various functions for the QUERY command
--*/
#include "pch.h"
#pragma hdrstop
#include <netdom.h>
#define VERIFY_QUERY_ONLY 0xFFFFFFFF
typedef enum _ND5_ACCOUNT_TYPE {
TypeWorkstation,
TypeServer,
TypeDomainController,
TypePDC,
TypeUnknown
} ND5_ACCOUNT_TYPE;
typedef enum _ND5_ACCOUNT_OPERATION {
OperationDisplay,
OperationVerify,
OperationReset
} ND5_ACCOUNT_OPERATION;
typedef struct _ND5_TRANS_TREE_NODE {
PDS_DOMAIN_TRUSTS DomainInfo;
ULONG ListIndex;
ULONG Children;
struct _ND5_TRANS_TREE_NODE *ChildList;
struct _ND5_TRANS_TREE_NODE *Parent;
} ND5_TRANS_TREE_NODE, *PND5_TRANS_TREE_NODE;
VOID
NetDompFreeBuiltTrustInfo(
IN PTRUSTED_DOMAIN_INFORMATION_EX TDInfoEx,
IN ULONG Count
)
{
ULONG i;
for ( i = 0; i < Count; i++ ) {
NetApiBufferFree( TDInfoEx[ i ].Name.Buffer );
}
NetApiBufferFree( TDInfoEx );
}
VOID
NetDompDumpTrustInfo(
IN PWSTR Domain,
IN PTRUSTED_DOMAIN_INFORMATION_EX TrustInfo
)
/*++
Routine Description:
This function will display the specified trusted domain info
Arguments:
Domain - Domain to be dumped
TrustInfo - Trust info the domain
Return Value:
VOID
--*/
{
ULONG Message, Type;
//
// Display the direction & name
//
Type = TrustInfo->TrustDirection & TRUST_DIRECTION_BIDIRECTIONAL;
switch ( Type ) {
case TRUST_DIRECTION_BIDIRECTIONAL:
Message = MSG_TRUST_BOTH_ARROW;
break;
case TRUST_DIRECTION_INBOUND:
Message = MSG_TRUST_IN_ARROW;
break;
case TRUST_DIRECTION_OUTBOUND:
Message = MSG_TRUST_OUT_ARROW;
break;
}
NetDompDisplayMessage( Message,
TrustInfo->Name.Buffer );
//
// Then, the type
//
switch ( TrustInfo->TrustType ) {
case TRUST_TYPE_DOWNLEVEL:
case TRUST_TYPE_UPLEVEL:
Message = MSG_TRUST_TYPE_WINDOWS;
break;
case TRUST_TYPE_MIT:
Message = MSG_TRUST_TYPE_MIT;
break;
default:
Message = MSG_TRUST_TYPE_OTHER;
break;
}
NetDompDisplayMessage( Message );
printf( "\n" );
}
//+----------------------------------------------------------------------------
//
// Function: GetTrustInfo
//
// Synopsis: Reads the trust info from the local TDO for the named domain.
//
//-----------------------------------------------------------------------------
DWORD
GetTrustInfo(PWSTR pwzDomain,
PND5_TRUST_INFO pLocalInfo,
PND5_TRUST_INFO pTrustInfo,
DWORD * pdwVerifyErr)
{
DWORD Win32Err = ERROR_SUCCESS;
NTSTATUS Status = STATUS_SUCCESS;
PTRUSTED_DOMAIN_INFORMATION_EX pTDIEx = NULL;
UNICODE_STRING usDomainName;
LSA_HANDLE hTrust;
*pdwVerifyErr = ERROR_ACCESS_DENIED;
RtlInitUnicodeString(&usDomainName, pwzDomain);
Status = LsaOpenTrustedDomainByName(pLocalInfo->LsaHandle,
&usDomainName,
TRUSTED_READ,
&hTrust);
if (!NT_SUCCESS(Status))
{
*pdwVerifyErr = LsaNtStatusToWinError(Status);
return *pdwVerifyErr;
}
Status = LsaQueryInfoTrustedDomain(hTrust,
TrustedDomainInformationEx,
(PVOID*)&pTDIEx);
if (!NT_SUCCESS(Status))
{
*pdwVerifyErr = LsaNtStatusToWinError(Status);
return *pdwVerifyErr;
}
pTrustInfo->TrustHandle = hTrust;
pTrustInfo->DomainName = &pTDIEx->Name;
pTrustInfo->FlatName = &pTDIEx->FlatName;
pTrustInfo->Sid = pTDIEx->Sid;
pTrustInfo->BlobToFree = pTDIEx;
if (pTDIEx->TrustType >= TRUST_TYPE_MIT)
{
pTrustInfo->Uplevel = FALSE;
pTrustInfo->Flags = NETDOM_TRUST_TYPE_MIT;
*pdwVerifyErr = ERROR_SUCCESS;
}
else
{
PDOMAIN_CONTROLLER_INFO pDcInfo = NULL;
PPOLICY_DNS_DOMAIN_INFO pPolicyDDI = NULL;
OBJECT_ATTRIBUTES OA;
UNICODE_STRING ServerU, DomainNameU;
// Get a DC name for the domain.
//
Win32Err = DsGetDcName(NULL,
pwzDomain,
NULL,
NULL,
DS_DIRECTORY_SERVICE_PREFERRED,
&pDcInfo );
if (ERROR_SUCCESS != Win32Err)
{
pTrustInfo->Flags = NETDOM_TRUST_FLAG_DOMAIN_NOT_FOUND;
*pdwVerifyErr = Win32Err;
return ERROR_SUCCESS;
}
// Save off the DC name.
//
Win32Err = NetApiBufferAllocate((wcslen(pDcInfo->DomainControllerName) + 1) * sizeof(WCHAR),
(PVOID*)&(pTrustInfo->Server));
if (ERROR_SUCCESS != Win32Err)
{
NetApiBufferFree(pDcInfo);
return Win32Err;
}
wcscpy(pTrustInfo->Server, pDcInfo->DomainControllerName);
NetApiBufferFree(pDcInfo);
Win32Err = NetpManageIPCConnect(pTrustInfo->Server,
L"",
L"",
NETSETUPP_NULL_SESSION_IPC);
if (ERROR_SUCCESS == Win32Err)
{
pTrustInfo->Connected = TRUE;
}
RtlInitUnicodeString(&ServerU, pTrustInfo->Server);
InitializeObjectAttributes( &OA, NULL, 0, NULL, NULL );
Status = LsaOpenPolicy(&ServerU,
&OA,
POLICY_VIEW_LOCAL_INFORMATION | POLICY_LOOKUP_NAMES,
&(pTrustInfo->LsaHandle));
if (NT_SUCCESS(Status))
{
// Find out if this is an uplevel or downlevel domain.
//
Status = LsaQueryInformationPolicy(pTrustInfo->LsaHandle,
PolicyDnsDomainInformation,
(PVOID *)&pPolicyDDI);
if (NT_SUCCESS(Status))
{
LsaFreeMemory(pPolicyDDI);
pTrustInfo->Uplevel = TRUE;
pTrustInfo->fWasDownlevel = FALSE;
}
else
{
if (RPC_NT_PROCNUM_OUT_OF_RANGE == Status)
{
pTrustInfo->Uplevel = pTrustInfo->fWasDownlevel = FALSE;
Status = STATUS_SUCCESS;
}
}
}
if (ERROR_NO_SUCH_DOMAIN == (*pdwVerifyErr = RtlNtStatusToDosError(Status)) ||
RPC_S_SERVER_UNAVAILABLE == *pdwVerifyErr)
{
pTrustInfo->Flags = NETDOM_TRUST_FLAG_DOMAIN_NOT_FOUND;
}
if (*pdwVerifyErr != ERROR_SUCCESS && pTrustInfo->Connected)
{
NetpManageIPCConnect(pTrustInfo->Server,
NULL,
NULL,
NETSETUPP_DISCONNECT_IPC);
pTrustInfo->Connected = FALSE;
}
}
return S_OK;
}
DWORD
NetDompQueryDirectTrust(
IN PWSTR Domain,
IN PND5_TRUST_INFO TrustInfo
)
/*++
Routine Description:
This function will get the trustinfo for the specified domain
Arguments:
Domain - Domain to get the trust info for
TrustInfo - Trust info to be obtained
Return Value:
ERROR_SUCCESS - The function succeeded
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
NTSTATUS Status = STATUS_SUCCESS;
LSA_ENUMERATION_HANDLE EnumerationContext = 0;
PTRUSTED_DOMAIN_INFORMATION_EX TDInfoEx = NULL, TempTDIEx = NULL;
PLSA_TRUST_INFORMATION TDInfo = NULL;
ULONG Count, i, TotalCount = 0, UserCount, j;
BOOL DisplayHeader = TRUE;
LPUSER_INFO_0 UserList = NULL;
ULONG ResumeHandle = 0;
PWSTR Lop, FullServer = NULL;
//
// Handle the uplevel case differently
//
if ( TrustInfo->Uplevel ) {
do {
Status = LsaEnumerateTrustedDomainsEx( TrustInfo->LsaHandle,
&EnumerationContext,
(PVOID*)&TDInfoEx,
0x1000,
&Count );
if ( NT_SUCCESS( Status ) || Status == STATUS_NO_MORE_ENTRIES ) {
if ( DisplayHeader ) {
NetDompDisplayMessage( MSG_TRUST_DIRECT_HEADER );
DisplayHeader = FALSE;
}
for ( i = 0; i < Count; i++ ) {
NetDompDumpTrustInfo( TrustInfo->DomainName->Buffer,
&TDInfoEx[ i ] );
}
}
LsaFreeMemory( TDInfoEx );
TDInfoEx = NULL;
} while ( Status == STATUS_MORE_ENTRIES );
} else {
//
// We'll have to do this the old fashioned way. That means that we'll enumerate all of
// the trust directly, save them off in a list, and then go through and enumerate all
// of the interdomain trust accounts and merge those into the list.
//
do {
Status = LsaEnumerateTrustedDomains( TrustInfo->LsaHandle,
&EnumerationContext,
(PVOID*)&TDInfo,
0x1000,
&Count );
if ( NT_SUCCESS( Status ) || Status == STATUS_NO_MORE_ENTRIES ) {
Win32Err = NetApiBufferAllocate( ( Count + TotalCount ) *
sizeof( TRUSTED_DOMAIN_INFORMATION_EX ),
(PVOID*)&TempTDIEx );
if ( Win32Err != ERROR_SUCCESS ) {
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlZeroMemory( TempTDIEx, ( Count + TotalCount ) *
sizeof( TRUSTED_DOMAIN_INFORMATION_EX ) );
RtlCopyMemory( TempTDIEx,
TDInfoEx,
TotalCount * sizeof( TRUSTED_DOMAIN_INFORMATION_EX ) );
for ( i = 0; i < Count; i++ ) {
TempTDIEx[ TotalCount + i ].TrustType = TRUST_TYPE_DOWNLEVEL;
TempTDIEx[ TotalCount + i ].TrustDirection = TRUST_DIRECTION_OUTBOUND;
Win32Err = NetApiBufferAllocate( TDInfo[ i ].Name.MaximumLength,
(PVOID*)&( TempTDIEx[ TotalCount + i ].Name.Buffer ) );
if ( Win32Err != ERROR_SUCCESS ) {
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlCopyMemory( TempTDIEx[ TotalCount + i ].Name.Buffer,
TDInfo[ i ].Name.Buffer,
TDInfo[ i ].Name.MaximumLength );
TempTDIEx[ TotalCount + i ].Name.Length = TDInfo[ i ].Name.Length;
TempTDIEx[ TotalCount + i ].Name.MaximumLength =
TDInfo[ i ].Name.MaximumLength;
}
if ( NT_SUCCESS( Status ) ) {
NetApiBufferFree( TDInfoEx );
TDInfoEx = TempTDIEx;
TotalCount += Count;
} else {
for ( j = 0; j < i; j++ ) {
NetApiBufferFree( TempTDIEx[ TotalCount + j ].Name.Buffer );
TempTDIEx[ TotalCount + j ].Name.Buffer = NULL;
}
NetApiBufferFree( TempTDIEx );
}
}
} while ( Status == STATUS_MORE_ENTRIES );
//
// Now, let's add in the user accounts
//
if ( NT_SUCCESS( Status ) ) {
if ( TrustInfo->Server && *( TrustInfo->Server ) != L'\\' ) {
Win32Err = NetApiBufferAllocate( ( wcslen( TrustInfo->Server ) + 3 ) * sizeof( WCHAR ),
( PVOID * )&FullServer );
if ( Win32Err == ERROR_SUCCESS ) {
swprintf( FullServer, L"\\\\%ws", TrustInfo->Server );
}
} else {
FullServer = TrustInfo->Server;
}
if ( Win32Err == ERROR_SUCCESS ) {
do {
Win32Err = NetUserEnum( FullServer,
0,
FILTER_INTERDOMAIN_TRUST_ACCOUNT,
( LPBYTE * )&UserList,
MAX_PREFERRED_LENGTH,
&Count,
&UserCount,
&ResumeHandle );
if ( Win32Err == ERROR_SUCCESS || Win32Err == ERROR_MORE_DATA ) {
for ( i = 0; i < Count; i++ ) {
Lop = wcsrchr( UserList[ i ].usri0_name, L'$' );
if ( Lop ) {
*Lop = UNICODE_NULL;
}
for ( j = 0; j < TotalCount; j++ ) {
if ( _wcsicmp( UserList[ i ].usri0_name,
TDInfoEx[ j ].Name.Buffer ) == 0 ) {
TDInfoEx[ j ].TrustDirection |= TRUST_DIRECTION_INBOUND;
break;
}
}
//
// If it wasn't found, add it...
//
if ( j == TotalCount ) {
Win32Err = NetApiBufferAllocate( ( 1 + TotalCount ) *
sizeof( TRUSTED_DOMAIN_INFORMATION_EX ),
(PVOID*)&TempTDIEx );
if ( Win32Err != ERROR_SUCCESS ) {
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RtlZeroMemory( TempTDIEx,
( 1 + TotalCount ) *
sizeof( TRUSTED_DOMAIN_INFORMATION_EX ) );
RtlCopyMemory( TempTDIEx,
TDInfoEx,
TotalCount * sizeof( TRUSTED_DOMAIN_INFORMATION_EX ) );
TempTDIEx[ TotalCount ].TrustType = TRUST_TYPE_DOWNLEVEL;
TempTDIEx[ TotalCount ].TrustDirection = TRUST_DIRECTION_INBOUND;
Win32Err = NetApiBufferAllocate(
( wcslen( UserList[ i ].usri0_name ) + 1 ) *
sizeof( WCHAR ) ,
(PVOID*)&( TempTDIEx[ TotalCount ].Name.Buffer ) );
if ( Win32Err != ERROR_SUCCESS ) {
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
wcscpy( TempTDIEx[ TotalCount ].Name.Buffer,
UserList[ i ].usri0_name );
RtlInitUnicodeString( &TempTDIEx[ TotalCount ].Name,
TempTDIEx[ TotalCount ].Name.Buffer );
if ( NT_SUCCESS( Status ) ) {
NetApiBufferFree( TDInfoEx );
TDInfoEx = TempTDIEx;
TotalCount++;
} else {
NetApiBufferFree( TempTDIEx );
}
}
if ( Lop ) {
*Lop = L'$';
}
}
NetApiBufferFree( UserList );
}
} while ( Win32Err == ERROR_MORE_DATA );
if( FullServer != TrustInfo->Server )
NetApiBufferFree( FullServer );
}
//
// If everything worked, then dump them all
//
if ( Win32Err == ERROR_SUCCESS ) {
if ( TotalCount > 0 ) {
NetDompDisplayMessage( MSG_TRUST_DIRECT_HEADER );
}
for ( i = 0; i < TotalCount; i++ ) {
NetDompDumpTrustInfo( TrustInfo->DomainName->Buffer,
&TDInfoEx[ i ] );
}
}
NetDompFreeBuiltTrustInfo( TDInfoEx, TotalCount );
} else {
Win32Err = RtlNtStatusToDosError( Status );
}
}
if ( Status == STATUS_NO_MORE_ENTRIES ) {
Status = STATUS_SUCCESS;
}
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = RtlNtStatusToDosError( Status );
}
return( Win32Err );
}
DWORD
NetDompFindChildrenForNode(
IN PWSTR LocalDomain,
IN ULONG DomainCount,
IN PDS_DOMAIN_TRUSTS DomainList,
IN OUT PND5_TRANS_TREE_NODE TreeNode,
IN OUT PND5_TRANS_TREE_NODE *DomainNode
)
/*++
Routine Description:
This recursive function will find all of the children for a given node in the trust list
Arguments:
LocalDomain - Domain to find the children for
DomainCount - Number of domains in the list
DomainList - List of domains
TreeNode - Tree to insert into
DomainNode - Pointer to the LocalDomain's node, if encountered
Return Value:
ERROR_SUCCESS - The function succeeded
ERROR_INVALID_PARAMETER - No server, workstation or machine was specified
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
ULONG i, Count = 0;
BOOL HandleDirect = FALSE;
//
// See how many
//
for ( i = 0; i < DomainCount; i++ ) {
if ( DomainList[ i ].ParentIndex == TreeNode->ListIndex &&
FLAG_ON( DomainList[ i ].Flags, DS_DOMAIN_IN_FOREST ) &&
!FLAG_ON( DomainList[ i ].Flags, DS_DOMAIN_TREE_ROOT)) {
Count++;
}
}
//
// If we have the current node, then make sure we get the direct trusts as well
//
if ( ( TreeNode->DomainInfo->DnsDomainName &&
_wcsicmp( LocalDomain, TreeNode->DomainInfo->DnsDomainName ) == 0 ) ||
_wcsicmp( LocalDomain, TreeNode->DomainInfo->NetbiosDomainName ) == 0 ) {
HandleDirect = TRUE;
*DomainNode = TreeNode;
for ( i = 0; i < DomainCount; i++ ) {
if ( FLAG_ON( DomainList[ i ].Flags, (DS_DOMAIN_DIRECT_OUTBOUND | DS_DOMAIN_DIRECT_INBOUND) ) &&
!FLAG_ON( DomainList[ i ].Flags, DS_DOMAIN_IN_FOREST ) &&
DomainList[ i ].ParentIndex == 0 ) {
Count++;
}
}
}
//
// Add 'em to the list
//
if ( Count ) {
Win32Err = NetApiBufferAllocate( Count * sizeof( ND5_TRANS_TREE_NODE ),
(PVOID*)&( TreeNode->ChildList ) );
if ( Win32Err == ERROR_SUCCESS ) {
RtlZeroMemory( TreeNode->ChildList, Count * sizeof( ND5_TRANS_TREE_NODE ) );
for ( i = 0; i < DomainCount && Win32Err == ERROR_SUCCESS; i++ ) {
if ( DomainList[ i ].ParentIndex == TreeNode->ListIndex &&
FLAG_ON( DomainList[ i ].Flags, DS_DOMAIN_IN_FOREST ) &&
!FLAG_ON( DomainList[ i ].Flags, DS_DOMAIN_TREE_ROOT) ) {
TreeNode->ChildList[ TreeNode->Children ].DomainInfo = &DomainList[ i ];
TreeNode->ChildList[ TreeNode->Children ].ListIndex = i;
TreeNode->ChildList[ TreeNode->Children ].Parent = TreeNode;
Win32Err = NetDompFindChildrenForNode( LocalDomain,
DomainCount,
DomainList,
&TreeNode->ChildList[ TreeNode->Children ],
DomainNode );
TreeNode->Children++;
DomainList[ i ].ParentIndex = 0xFFFFFFFF;
}
}
//
// Now, the other local entries
//
if ( Win32Err == ERROR_SUCCESS && HandleDirect ) {
for ( i = 0; i < DomainCount; i++ ) {
if ( FLAG_ON( DomainList[ i ].Flags, (DS_DOMAIN_DIRECT_OUTBOUND | DS_DOMAIN_DIRECT_INBOUND) ) &&
!FLAG_ON( DomainList[ i ].Flags, DS_DOMAIN_IN_FOREST ) &&
DomainList[ i ].ParentIndex == 0 ) {
TreeNode->ChildList[ TreeNode->Children ].DomainInfo = &DomainList[ i ];
TreeNode->ChildList[ TreeNode->Children ].ListIndex = i;
TreeNode->Children++;
DomainList[ i ].ParentIndex = 0xFFFFFFFF;
}
}
}
}
}
return( Win32Err );
}
DWORD
NetDompBuildTransTrustTree(
IN PWSTR LocalDomain,
IN ULONG DomainCount,
IN PDS_DOMAIN_TRUSTS DomainList,
OUT PND5_TRANS_TREE_NODE *TreeRoot,
OUT PND5_TRANS_TREE_NODE *CurrentDomainNode
)
/*++
Routine Description:
This function will build the transative trust tree for the given trust list
Arguments:
LocalDomain - Current domain
DomainCount - Number of domains in the list
DomainList - List of domains
TreeRoot - Tree root
CurrentDomainNode - Pointer to the LocalDomain's node
Return Value:
ERROR_SUCCESS - The function succeeded
ERROR_INVALID_PARAMETER - No server, workstation or machine was specified
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
PND5_TRANS_TREE_NODE Root = NULL, Temp = NULL, DomainNode = NULL;
PDS_DOMAIN_TRUSTS TDRoot = NULL;
ULONG i, Index;
//
// First, find the tree root.
//
for ( i = 0; i < DomainCount; i++ ) {
if ( DomainList[ i ].ParentIndex == 0 &&
FLAG_ON( DomainList[ i ].Flags, DS_DOMAIN_TREE_ROOT ) ) {
TDRoot = &DomainList[ i ];
Index = i;
break;
}
}
if ( TDRoot == NULL ) {
//
// Find ourselves, and make us the root
//
for ( i = 0; i < DomainCount; i++ ) {
if ( ( DomainList[ i ].DnsDomainName &&
_wcsicmp( LocalDomain, DomainList[ i ].DnsDomainName ) == 0 ) ||
_wcsicmp( LocalDomain, DomainList[ i ].NetbiosDomainName ) == 0 ) {
TDRoot = &DomainList[ i ];
Index = i;
break;
}
}
}
//
// If we still don't have one, bail...
//
if ( TDRoot == NULL) {
Win32Err = ERROR_INVALID_DOMAIN_STATE;
goto BuildTransExit;
}
Win32Err = NetApiBufferAllocate( sizeof( ND5_TRANS_TREE_NODE ), (PVOID*)&Root );
if ( Win32Err != ERROR_SUCCESS ) {
goto BuildTransExit;
}
RtlZeroMemory( Root, sizeof( ND5_TRANS_TREE_NODE ) );
Root->DomainInfo = TDRoot;
Root->ListIndex = Index;
TDRoot->ParentIndex = 0xFFFFFFFF;
Win32Err = NetDompFindChildrenForNode( LocalDomain,
DomainCount,
DomainList,
Root,
&DomainNode );
BuildTransExit:
if ( Win32Err == ERROR_SUCCESS ) {
*TreeRoot = Root;
*CurrentDomainNode = DomainNode;
}
return( Win32Err );
}
DWORD
NetDompGetTrustDirection(
IN PND5_TRUST_INFO TrustingInfo,
IN PND5_TRUST_INFO TrustedInfo,
IN OUT PDWORD Direction
)
/*++
Routine Description:
This function will get the direction of the trust between the 2 specified domains
Arguments:
TrustingInfo - Domain #1
TrustedInfo - Domain #2
Direction - Where the trust direction is returned
Return Value:
ERROR_SUCCESS - The function succeeded
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
NTSTATUS Status;
LSA_HANDLE TrustedDomain;
PTRUSTED_DOMAIN_INFORMATION_EX TDIEx = NULL;
PUSER_INFO_1 UI1 = NULL;
WCHAR AccountName[ UNLEN + 1 ];
if ( TrustingInfo->Uplevel ) {
Status = LsaQueryTrustedDomainInfoByName( TrustingInfo->LsaHandle,
TrustedInfo->DomainName,
TrustedDomainInformationEx,
(PVOID*)&TDIEx );
if (STATUS_OBJECT_NAME_NOT_FOUND == Status && TrustedInfo->Uplevel)
{
// Pre-existing TDOs for domains upgraded from NT4 to NT5 will continue to
// have a flat name.
//
TrustedInfo->fWasDownlevel = TRUE;
Status = LsaQueryTrustedDomainInfoByName( TrustingInfo->LsaHandle,
TrustedInfo->FlatName,
TrustedDomainInformationEx,
(PVOID*)&TDIEx );
}
if ( NT_SUCCESS( Status ) ) {
DBG_VERBOSE(("Trust to domain %ws has direction %d\n", TrustedInfo->DomainName->Buffer,
TDIEx->TrustDirection));
*Direction = TDIEx->TrustDirection;
LsaFreeMemory( TDIEx );
}
Win32Err = RtlNtStatusToDosError( Status );
} else {
*Direction = 0;
Status = LsaOpenTrustedDomain( TrustingInfo->LsaHandle,
TrustedInfo->Sid,
MAXIMUM_ALLOWED,
&TrustedDomain );
if ( Status != STATUS_OBJECT_NAME_NOT_FOUND ) {
*Direction = TRUST_DIRECTION_OUTBOUND;
}
if ( NT_SUCCESS( Status ) ) {
LsaClose( TrustedDomain );
}
if ( TrustedInfo->FlatName->Length > DNLEN * sizeof( WCHAR ) ) {
Win32Err = ERROR_INVALID_DOMAINNAME;
} else {
//
// Build the account name...
//
swprintf( AccountName, L"%ws$", TrustedInfo->FlatName->Buffer );
Win32Err = NetUserGetInfo( TrustingInfo->Server,
AccountName,
1,
( LPBYTE * )&UI1 );
if ( Win32Err != ERROR_NO_SUCH_USER ) {
*Direction |= TRUST_DIRECTION_INBOUND;
}
if ( Win32Err == ERROR_SUCCESS ) {
NetApiBufferFree( UI1 );
}
}
}
return( Win32Err );
}
/*++
DWORD
NetDompFindChildNode(
IN PUNICODE_STRING ChildToFind,
IN PND5_TRANS_TREE_NODE Current,
IN PND5_TRANS_TREE_NODE Skip,
IN ULONG Display,
BOOL IncludeParent
)
Routine Description:
This function will find the child of the current node
Arguments:
ChildToFind - Child domain to find
Current - Where we are in the tree
Skip - Node to not process if we are coming from our parent
Display - Resource id of string to display
IncludeParent - If TRUE, work up the tree as well as down
Return Value:
ERROR_SUCCESS - The function succeeded
ERROR_INVALID_PARAMETER - No server, workstation or machine was specified
{
DWORD Win32Err = ERROR_NOT_FOUND;
ULONG i;
UNICODE_STRING CurrentDomain;
BOOL Found = FALSE;
if ( !Current ) {
return( Win32Err );
}
for ( i = 0; i < Current->Children && !Found && Win32Err == ERROR_NOT_FOUND; i++ ) {
RtlInitUnicodeString( &CurrentDomain,
Current->ChildList[ i ].DomainInfo->DnsDomainName ?
Current->ChildList[ i ].DomainInfo->DnsDomainName :
Current->ChildList[ i ].DomainInfo->NetbiosDomainName );
if ( RtlCompareUnicodeString( &CurrentDomain,
ChildToFind,
TRUE ) == 0 ) {
Found = TRUE;
break;
} else {
if ( Skip != &Current->ChildList[ i ] ) {
Win32Err = NetDompFindChildNode( ChildToFind,
&Current->ChildList[ i ],
NULL,
Display,
FALSE );
if ( Win32Err == ERROR_SUCCESS ) {
break;
}
}
}
}
if ( Win32Err == ERROR_NOT_FOUND && IncludeParent ) {
if ( Current->Parent && !Found ) {
RtlInitUnicodeString( &CurrentDomain,
Current->Parent->DomainInfo->DnsDomainName ?
Current->Parent->DomainInfo->DnsDomainName :
Current->Parent->DomainInfo->NetbiosDomainName );
if ( RtlCompareUnicodeString( &CurrentDomain,
ChildToFind,
TRUE ) == 0 ) {
Found = TRUE;
}
}
if ( !Found ) {
Win32Err = NetDompFindChildNode( ChildToFind,
Current->Parent,
Current,
Display,
TRUE );
}
}
if ( Win32Err == ERROR_SUCCESS && Display ) {
NetDompDisplayMessage( Display,
CurrentDomain.Buffer );
}
if ( Found ) {
Win32Err = ERROR_SUCCESS;
}
return( Win32Err );
}
--*/
DWORD
NetDompDisplayTransTrustStatus(
IN PND5_TRUST_INFO TrustInfo,
IN PWSTR DomainName,
//IN PND5_TRANS_TREE_NODE CurrentDomain,
IN DWORD Direction,
IN DWORD TrustStatus
)
/*++
Routine Description:
This function will display the status for a trust
Arguments:
TrustInfo - Trust info to display the status for
DomainName - Name of the domain (if TrustInfo isn't available)
CurrentDomain - Current domain node pointer
Direction - Direction of the trust
TrustStatus - Status code from verifying the trust
Return Value:
ERROR_SUCCESS - The function succeeded
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
ULONG Message, Type;
//
// Display the direction & name
//
Type = Direction & TRUST_DIRECTION_BIDIRECTIONAL;
switch ( Type ) {
case 0:
Message = MSG_TRUST_TRANS_NO_ARROW;
break;
case TRUST_DIRECTION_BIDIRECTIONAL:
Message = MSG_TRUST_TRANS_BOTH_ARROW;
break;
case TRUST_DIRECTION_INBOUND:
Message = MSG_TRUST_TRANS_IN_ARROW;
break;
case TRUST_DIRECTION_OUTBOUND:
Message = MSG_TRUST_TRANS_OUT_ARROW;
break;
}
NetDompDisplayMessage( Message, TrustInfo ? TrustInfo->DomainName->Buffer : DomainName );
//
// Then, the type
//
if (TrustInfo && TrustInfo->Flags & NETDOM_TRUST_TYPE_INDIRECT)
{
Message = MSG_TRUST_TYPE_INDIRECT;
}
else
{
if (TrustInfo && TrustInfo->Flags & NETDOM_TRUST_TYPE_MIT)
{
Message = MSG_TRUST_TYPE_MIT;
}
else
{
Message = MSG_TRUST_TYPE_WINDOWS;
}
}
NetDompDisplayMessage( Message );
//
// Finally, the status.
//
if (TrustInfo && TrustInfo->Flags & NETDOM_TRUST_FLAG_DOMAIN_NOT_FOUND)
{
TrustStatus = ERROR_NO_SUCH_DOMAIN;
}
switch ( TrustStatus ) {
case ERROR_SUCCESS:
NetDompDisplayMessage( MSG_TRUST_VERIFIED );
break;
case ERROR_NO_SUCH_DOMAIN:
NetDompDisplayMessage( MSG_TRUST_NO_DOMAIN );
break;
case ERROR_ACCESS_DENIED:
NetDompDisplayMessage( MSG_TRUST_ACCESS_DENIED );
break;
case VERIFY_QUERY_ONLY:
printf( "\n" );
break;
default:
NetDompDisplayMessage( MSG_TRUST_BROKEN );
break;
}
/* this doesn't work.
if ( TrustInfo ) {
Win32Err = NetDompFindChildNode( TrustInfo->DomainName,
CurrentDomain,
NULL,
MSG_TRUST_VIA,
TRUE );
} */
return( Win32Err );
}
DWORD
NetDompQueryTrust(
IN PWSTR Domain,
IN PND5_AUTH_INFO AuthInfo,
IN PWSTR pwzServer,
IN BOOL Direct,
IN BOOL Verify
)
/*++
Routine Description:
This function will get the list of trusts for a domain
Arguments:
Domain - Domain to get the trust for
AuthInfo - Username and password to use to connect to the machine
pwzServer - Server specified on command line, if any
Direct - if TRUE, get only the DIRECTLY trusted domains
Verify - If TRUE, verify that the trusts are valid
Return Value:
ERROR_SUCCESS - The function succeeded
ERROR_INVALID_PARAMETER - No server, workstation or machine was specified
--*/
{
DWORD Win32Err = ERROR_SUCCESS, VerifyErr;
ND5_TRUST_INFO TrustInfo, OtherInfo;
ULONG Count = 0, i;
PDS_DOMAIN_TRUSTS rgTrustedDomains = NULL;
ULONG Message, Type, Direction;
//PND5_TRANS_TREE_NODE TreeRoot = NULL, CurrentDomainNode;
PWSTR CurrentDomain;
RtlZeroMemory( &TrustInfo, sizeof( ND5_TRUST_INFO ) );
Win32Err = NetDompTrustGetDomInfo( Domain,
pwzServer,
AuthInfo,
&TrustInfo,
FALSE,
FALSE,
FALSE);
if ( Win32Err == ERROR_SUCCESS ) {
if ( Direct || !TrustInfo.Uplevel ) {
Win32Err = NetDompQueryDirectTrust( Domain,
&TrustInfo );
} else {
Win32Err = DsEnumerateDomainTrusts(TrustInfo.Server,
DS_DOMAIN_IN_FOREST | DS_DOMAIN_DIRECT_OUTBOUND | DS_DOMAIN_DIRECT_INBOUND,
&rgTrustedDomains,
&Count);
if ( Win32Err == ERROR_SUCCESS ) {
if ( Count ) {
NetDompDisplayMessage((Verify) ? MSG_TRUST_TRANS_HEADER_VERIFY :
MSG_TRUST_TRANS_HEADER);
}
/* this doesn't work.
Win32Err = NetDompBuildTransTrustTree( Domain,
Count,
rgTrustedDomains,
&TreeRoot,
&CurrentDomainNode ); */
if ( Win32Err == ERROR_SUCCESS ) {
for ( i = 0; i < Count; i++ ) {
//
// Make sure we aren't connecting to ourselves...
//
CurrentDomain = rgTrustedDomains[ i ].DnsDomainName ?
rgTrustedDomains[ i ].DnsDomainName :
rgTrustedDomains[ i ].NetbiosDomainName;
if ( !_wcsicmp( CurrentDomain, TrustInfo.DomainName->Buffer ) ) {
continue;
}
RtlZeroMemory(&OtherInfo, sizeof(ND5_TRUST_INFO));
if (rgTrustedDomains[i].Flags & DS_DOMAIN_DIRECT_OUTBOUND ||
rgTrustedDomains[i].Flags & DS_DOMAIN_DIRECT_INBOUND)
{
// There is a direct trust to the domain, therefore a TDO
// exists, so read the domain data locally.
//
Win32Err = GetTrustInfo(CurrentDomain,
&TrustInfo,
&OtherInfo,
&VerifyErr);
if (ERROR_SUCCESS == Win32Err)
{
VerifyErr = NetDompGetTrustDirection(&TrustInfo,
&OtherInfo,
&Direction);
}
else
{
Direction = 0;
}
}
else
{
Win32Err = NetDompTrustGetDomInfo(CurrentDomain,
NULL,
AuthInfo,
&OtherInfo,
FALSE,
FALSE, TRUE);
VerifyErr = Win32Err;
OtherInfo.Flags |= NETDOM_TRUST_TYPE_INDIRECT;
//
// If the trust is indirect, it must be a forest trust.
// Enterprise trusts always have a bi-di path.
//
Direction = TRUST_DIRECTION_BIDIRECTIONAL;
}
if (ERROR_SUCCESS == VerifyErr)
{
if (Verify
&& !(NETDOM_TRUST_TYPE_MIT & OtherInfo.Flags)
&& (DS_DOMAIN_DIRECT_OUTBOUND & rgTrustedDomains[i].Flags))
{
// Verify only direct, outbound, non-MIT trusts.
// Can't verify incoming without creds to the other
// domain.
//
VerifyErr = NetDompVerifyTrust(&TrustInfo,
&OtherInfo,
FALSE);
}
else
{
VerifyErr = VERIFY_QUERY_ONLY;
}
NetDompDisplayTransTrustStatus( &OtherInfo,
NULL,
//CurrentDomainNode,
Direction,
VerifyErr );
NetDompFreeDomInfo( &OtherInfo );
} else {
if ( !Verify ) {
VerifyErr = VERIFY_QUERY_ONLY;
}
NetDompDisplayTransTrustStatus( NULL,
rgTrustedDomains[ i ].DnsDomainName ?
rgTrustedDomains[ i ].DnsDomainName :
rgTrustedDomains[ i ].NetbiosDomainName,
//CurrentDomainNode,
Direction,
VerifyErr );
}
}
}
NetApiBufferFree( rgTrustedDomains );
}
}
NetDompFreeDomInfo( &TrustInfo );
}
return( Win32Err );
}
DWORD
NetDompQueryDisplayOus(
IN PWSTR Domain,
IN PND5_AUTH_INFO AuthInfo
)
/*++
Routine Description:
This function will list the OUs under which the specified user can create a computer object
Arguments:
Domain - Domain to connect to
AuthInfo - Username and password to connect to the domain with
Return Value:
ERROR_SUCCESS - The function succeeded
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
PWSTR *OuList;
ULONG OuCount = 0, i;
//
// Get the list and display it
//
LOG_VERBOSE(( MSG_VERBOSE_DETERMINE_OU ));
Win32Err = NetGetJoinableOUs( NULL,
Domain,
AuthInfo->User,
AuthInfo->Password,
&OuCount,
&OuList );
if ( Win32Err == ERROR_SUCCESS ) {
NetDompDisplayMessage( MSG_OU_LIST );
for ( i = 0; i < OuCount; i++ ) {
printf( "%ws\n", OuList[ i ] );
}
NetApiBufferFree( OuList );
}
return( Win32Err );
}
DWORD
NetDompQueryFsmo(
IN PWSTR Domain,
IN PND5_AUTH_INFO AuthInfo
)
/*++
Routine Description:
This function will list the machines holding the various FSMO roles
Arguments:
Domain - Domain to connect to
AuthInfo - Username and password to connect to the domain with
Return Value:
ERROR_SUCCESS - The function succeeded
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
PWSTR User = NULL, Separator = NULL, pwzDomain = NULL, FsmoServer = NULL, ServerPath;
PDOMAIN_CONTROLLER_INFO DcInfo = NULL;
HANDLE DsHandle = NULL;
RPC_AUTH_IDENTITY_HANDLE AuthHandle;
PDS_NAME_RESULT DsRoles = NULL;
PLDAP Ldap = NULL;
ULONG i;
ULONG DisplayMap[ ] = {
MSG_FSMO_SCHEMA,
MSG_FSMO_DOMAIN,
MSG_FSMO_PDC,
MSG_FSMO_RID,
MSG_FSMO_INFRASTRUCTURE
};
//
// Find a domain controller
//
LOG_VERBOSE(( MSG_VERBOSE_FIND_DC, Domain ));
Win32Err = DsGetDcName( NULL,
Domain,
NULL,
NULL,
DS_DIRECTORY_SERVICE_REQUIRED,
&DcInfo );
if ( Win32Err == ERROR_SUCCESS ) {
if ( AuthInfo->User ) {
Separator = wcschr( AuthInfo->User, L'\\' );
if ( Separator ) {
*Separator = UNICODE_NULL;
User = Separator + 1;
if (!*User) {
return ERROR_INVALID_PARAMETER;
}
pwzDomain = AuthInfo->User;
} else {
User = AuthInfo->User;
pwzDomain = Domain;
}
}
Win32Err = DsMakePasswordCredentials( User,
pwzDomain,
AuthInfo->Password,
&AuthHandle );
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = DsBindWithCred( DcInfo->DomainControllerName,
NULL,
AuthHandle,
&DsHandle );
DsFreePasswordCredentials( AuthHandle );
}
//
// Now, start getting the info
//
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = DsListRoles( DsHandle,
&DsRoles );
if ( Win32Err == ERROR_SUCCESS ) {
ASSERT( sizeof( DisplayMap ) / sizeof( ULONG ) == DsRoles->cItems );
for ( i = 0; i < sizeof( DisplayMap ) / sizeof( ULONG ); i++ ) {
ULONG Type = 0;
//
// Skip items that may not exist
//
if ( DsRoles->rItems[ i ].status != DS_NAME_NO_ERROR ) {
continue;
}
ServerPath = wcschr( DsRoles->rItems[ i ].pName, L',' );
if ( ServerPath ) {
ServerPath++;
} else {
ServerPath = DsRoles->rItems[ i ].pName;
}
if ( !Ldap ) {
Win32Err = NetDompLdapBind( DcInfo->DomainControllerName + 2,
User == AuthInfo->User ? NULL : AuthInfo->User,
User,
AuthInfo->Password,
LDAP_AUTH_SSPI,
&Ldap );
}
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = NetDompLdapReadOneAttribute( Ldap,
ServerPath,
L"dNSHostName",
&FsmoServer );
if ( Win32Err == ERROR_SUCCESS ) {
NetDompDisplayMessage( DisplayMap[ i ], FsmoServer );
NetApiBufferFree( FsmoServer );
}
}
}
}
}
}
if ( DsHandle ) {
DsUnBind( &DsHandle );
}
if ( DsRoles ) {
DsFreeNameResult( DsRoles );
}
if ( Separator ) {
*Separator = L'\\';
}
NetApiBufferFree( DcInfo );
return( Win32Err );
}
DWORD
NetDompDisplayMachineByType(
IN PWSTR AccountName,
IN PND5_AUTH_INFO AuthInfo,
IN ND5_ACCOUNT_TYPE DesiredType,
IN ND5_ACCOUNT_TYPE KnownType,
IN BOOL DisplayOnError
)
/*++
Routine Description:
This function display machines of the specified type that are joined to the domain
Arguments:
AccountName - Name of the machine to get the info from
AuthInfo - Username and password to connect to the domain with
DesiredType - Type of machine to get
KnownType - Whether the machine type is known or not
DisplayOnError - If TRUE, display a message if an error is encountered
Return Value:
ERROR_SUCCESS - The function succeeded
ERROR_UNSUPPORTED_TYPE - An unknown type was encountered
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
PSERVER_INFO_101 SrvInfo = NULL;
PWSTR AccountChar;
AccountChar = wcsrchr( AccountName, L'$' );
if ( AccountChar ) {
*AccountChar = UNICODE_NULL;
}
//
// See if we have to get the type or not
//
if ( KnownType == TypeUnknown ) {
Win32Err = NetpManageIPCConnect( AccountName,
AuthInfo->User,
AuthInfo->Password,
NETSETUPP_CONNECT_IPC );
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = NetServerGetInfo( AccountName,
101,
( LPBYTE * )&SrvInfo );
NetpManageIPCConnect( AccountName,
AuthInfo->User,
AuthInfo->Password,
NETSETUPP_DISCONNECT_IPC );
}
if ( Win32Err == ERROR_SUCCESS ) {
if ( FLAG_ON( SrvInfo->sv101_type, SV_TYPE_DOMAIN_BAKCTRL ) ) {
KnownType = TypeDomainController;
} else if ( FLAG_ON( SrvInfo->sv101_type, SV_TYPE_DOMAIN_CTRL ) ) {
if ( DesiredType == TypeDomainController ) {
KnownType = TypeDomainController;
} else {
KnownType = TypePDC;
}
} else if ( FLAG_ON( SrvInfo->sv101_type, SV_TYPE_WORKSTATION ) ) {
KnownType = TypeWorkstation;
} else {
Win32Err = ERROR_UNSUPPORTED_TYPE;
}
} else {
LOG_VERBOSE(( MSG_VERBOSE_FAIL_MACH_TYPE, AccountName ));
ERROR_VERBOSE(( Win32Err ));
if ( DisplayOnError ) {
KnownType = DesiredType;
}
}
}
if ( KnownType == DesiredType && ( Win32Err == ERROR_SUCCESS || DisplayOnError ) ) {
if ( Win32Err != ERROR_SUCCESS ) {
NetDompDisplayMessage( MSG_WKSTA_OR_SERVER, AccountName );
Win32Err = ERROR_SUCCESS;
} else {
printf( "%ws\n", AccountName );
}
}
return( Win32Err );
}
DWORD
NetDompQueryMachines(
IN ND5_ACCOUNT_OPERATION Operation,
IN PWSTR Domain,
IN PND5_AUTH_INFO AuthInfo,
IN PWSTR pwzServer,
IN ND5_ACCOUNT_TYPE AccountType,
IN ULONG MessageId
)
/*++
Routine Description:
This function will list the machines in a domian
Arguments:
Operation - Whether to display/verify/reset the machines
Domain - Domain to connect to
AuthInfo - Username and password to connect to the domain with
pwzServer - Optional server name specified on command line, must be NULL for PDC operation.
AccountType - Type of accounts to display
MessageId - Resource ID of string to display
Return Value:
ERROR_SUCCESS - The function succeeded
--*/
{
DWORD Win32Err = ERROR_SUCCESS, Win32Err2;
PWSTR pwzUncServer = NULL, Lop, pwzUser = NULL, pwzDomain = NULL;
BOOL Connected = FALSE, fDsDcInfoAllocated = FALSE, fFreeServer = FALSE;
ULONG Type = 0;
PDOMAIN_CONTROLLER_INFO DcInfo = NULL;
ULONG AccountTypeMap[] = {
FILTER_WORKSTATION_TRUST_ACCOUNT,
FILTER_WORKSTATION_TRUST_ACCOUNT,
FILTER_SERVER_TRUST_ACCOUNT,
FILTER_SERVER_TRUST_ACCOUNT,
FILTER_WORKSTATION_TRUST_ACCOUNT
};
LPUSER_INFO_0 UserList = NULL;
ULONG ResumeHandle = 0, Count = 0, TotalCount = 0, i;
ULONG DsGetDcOptions = DS_DIRECTORY_SERVICE_PREFERRED;
PDS_DOMAIN_CONTROLLER_INFO_1 pDsDcInfo;
if ( AccountType == TypeUnknown ) {
return( ERROR_INVALID_PARAMETER );
}
if (!pwzServer)
{
if ( AccountType == TypePDC ) {
DsGetDcOptions |= DS_PDC_REQUIRED;
}
LOG_VERBOSE(( MSG_VERBOSE_FIND_DC, Domain ));
Win32Err = DsGetDcName( NULL,
Domain,
NULL,
NULL,
DsGetDcOptions,
&DcInfo );
if (ERROR_SUCCESS != Win32Err)
{
return Win32Err;
}
if (AccountType == TypePDC)
{
NetDompDisplayMessage( MessageId );
NetDompDisplayMachineByType( DcInfo->DomainControllerName + 2,
AuthInfo,
TypePDC,
TypePDC,
TRUE );
goto QueryMachinesExit;
}
pwzUncServer = DcInfo->DomainControllerName;
}
else
{
// Server supplied on the command line. See if it has the needed backslashes.
//
if (L'\\' == *pwzServer)
{
if (wcslen(pwzServer) < 3 || L'\\' != pwzServer[1])
{
return ERROR_INVALID_PARAMETER;
}
pwzUncServer = pwzServer;
}
else
{
Win32Err = NetApiBufferAllocate((wcslen(pwzServer) + 3) * sizeof(WCHAR),
(PVOID*)&pwzUncServer);
if (ERROR_SUCCESS != Win32Err)
{
return Win32Err;
}
wsprintf(pwzUncServer, L"\\\\%s", pwzServer);
fFreeServer = TRUE;
}
}
LOG_VERBOSE(( MSG_VERBOSE_ESTABLISH_SESSION, pwzUncServer ));
Win32Err = NetpManageIPCConnect( pwzUncServer,
AuthInfo->User,
AuthInfo->Password,
NETSETUPP_CONNECT_IPC );
if ( Win32Err == ERROR_SUCCESS ) {
Connected = TRUE;
}
else {
goto QueryMachinesExit;
}
NetDompDisplayMessage( MessageId );
//
// Now, do the enumeration
//
if (TypeDomainController == AccountType) {
HANDLE hDS;
RPC_AUTH_IDENTITY_HANDLE hID;
if (AuthInfo->User) {
pwzUser = wcschr(AuthInfo->User, L'\\');
if (pwzUser) {
//
// backslash found, replace with NULL and point to next char.
//
*pwzUser = UNICODE_NULL;
pwzUser++;
if (!*pwzUser) {
return ERROR_INVALID_PARAMETER;
}
pwzDomain = AuthInfo->User;
}
else {
pwzUser = AuthInfo->User;
pwzDomain = Domain;
}
}
Win32Err = DsMakePasswordCredentials( pwzUser,
pwzDomain,
AuthInfo->Password,
&hID);
if ( Win32Err != ERROR_SUCCESS ) {
goto QueryMachinesExit;
}
Win32Err = DsBindWithCred(pwzUncServer, NULL, hID, &hDS);
DsFreePasswordCredentials(hID);
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = DsGetDomainControllerInfo(hDS, Domain, 1, &Count, (PVOID*)&pDsDcInfo);
DsUnBind(&hDS);
if ( Win32Err != ERROR_SUCCESS ) {
goto QueryMachinesExit;
}
fDsDcInfoAllocated = TRUE;
for ( i = 0; i < Count; i++ ) {
switch ( Operation ) {
case OperationDisplay:
//
// Ignore errors from this function
//
NetDompDisplayMachineByType( pDsDcInfo[ i ].NetbiosName,
AuthInfo,
TypeDomainController,
TypeDomainController,
TRUE );
break;
case OperationVerify:
Win32Err2 = NetDompVerifyServerSC( Domain,
pDsDcInfo[ i ].NetbiosName,
AuthInfo,
MSG_QUERY_VERIFY_OK,
0 );
if ( Win32Err2 != ERROR_SUCCESS ) {
NetDompDisplayMessageAndError( MSG_QUERY_VERIFY_BAD,
Win32Err2,
pDsDcInfo[ i ].NetbiosName );
}
break;
case OperationReset:
Win32Err2 = NetDompResetServerSC( Domain,
pDsDcInfo[ i ].NetbiosName,
NULL,
AuthInfo,
MSG_QUERY_VERIFY_OK,
0 );
if ( Win32Err2 != ERROR_SUCCESS ) {
NetDompDisplayMessageAndError( MSG_QUERY_VERIFY_BAD,
Win32Err2,
pDsDcInfo[ i ].NetbiosName );
}
break;
default:
Win32Err2 = ERROR_INVALID_PARAMETER;
break;
}
}
goto QueryMachinesExit;
}
else {
// DsBind will return EPT_S_NOT_REGISTERED if a downlevel DC is targetted.
// If so, fall through to the NetUserEnum code.
//
if (EPT_S_NOT_REGISTERED != Win32Err) {
goto QueryMachinesExit;
}
}
}
do {
Win32Err = NetUserEnum( pwzUncServer,
0,
AccountTypeMap[ AccountType ],
( LPBYTE * )&UserList,
MAX_PREFERRED_LENGTH,
&Count,
&TotalCount,
&ResumeHandle );
if ( Win32Err == ERROR_SUCCESS || Win32Err == ERROR_MORE_DATA ) {
for ( i = 0; i < Count; i++ ) {
switch ( Operation ) {
case OperationDisplay:
//
// Ignore errors from this function
//
NetDompDisplayMachineByType( UserList[ i ].usri0_name,
AuthInfo,
AccountType,
TypeUnknown,
TRUE );
break;
case OperationVerify:
Lop = wcsrchr( UserList[ i ].usri0_name, L'$' );
if ( Lop ) {
*Lop = UNICODE_NULL;
}
Win32Err2 = NetDompVerifyServerSC( Domain,
UserList[ i ].usri0_name,
AuthInfo,
MSG_QUERY_VERIFY_OK,
0 );
if ( Win32Err2 != ERROR_SUCCESS ) {
NetDompDisplayMessageAndError( MSG_QUERY_VERIFY_BAD,
Win32Err2,
UserList[ i ].usri0_name );
}
if ( Lop ) {
*Lop = L'$';
}
break;
case OperationReset:
Lop = wcsrchr( UserList[ i ].usri0_name, L'$' );
if ( Lop ) {
*Lop = UNICODE_NULL;
}
Win32Err2 = NetDompResetServerSC( Domain,
UserList[ i ].usri0_name,
NULL,
AuthInfo,
MSG_QUERY_VERIFY_OK,
0 );
if ( Win32Err2 != ERROR_SUCCESS ) {
NetDompDisplayMessageAndError( MSG_QUERY_VERIFY_BAD,
Win32Err2,
UserList[ i ].usri0_name );
}
if ( Lop ) {
*Lop = L'$';
}
break;
default:
Win32Err2 = ERROR_INVALID_PARAMETER;
break;
}
}
NetApiBufferFree( UserList );
}
} while ( Win32Err == ERROR_MORE_DATA );
QueryMachinesExit:
if ( Connected ) {
LOG_VERBOSE(( MSG_VERBOSE_DELETE_SESSION, pwzUncServer ));
NetpManageIPCConnect( pwzUncServer,
NULL,
NULL,
NETSETUPP_DISCONNECT_IPC );
}
if (fFreeServer)
{
NetApiBufferFree(pwzUncServer);
}
if (fDsDcInfoAllocated)
{
DsFreeDomainControllerInfo(1, Count, pDsDcInfo);
}
if (DcInfo)
{
NetApiBufferFree(DcInfo);
}
return( Win32Err );
}
DWORD
NetDompHandleQuery(ARG_RECORD * rgNetDomArgs)
/*++
Routine Description:
This function will move a machine from one domain to another
Arguments:
Args - List of command line arguments
Return Value:
ERROR_INVALID_PARAMETER - No object name was supplied
--*/
{
DWORD Win32Err = ERROR_SUCCESS;
PWSTR Domain = NULL, Server = NULL;
ND5_AUTH_INFO DomainUser;
ND5_ACCOUNT_OPERATION Operation = OperationDisplay;
ULONG DisplayFlag = 0;
RtlZeroMemory( &DomainUser, sizeof( ND5_AUTH_INFO ) );
Win32Err = NetDompValidateSecondaryArguments(rgNetDomArgs,
eQueryPDC,
eQueryServer,
eQueryWksta,
eQueryDC,
eQueryOU,
eQueryFSMO,
eQueryTrust,
eCommDomain,
eCommUserNameD,
eCommPasswordD,
eCommServer,
eCommReset,
eQueryDirect,
eCommVerbose,
eCommVerify,
eArgEnd);
if ( Win32Err != ERROR_SUCCESS ) {
DisplayHelp(ePriQuery);
return Win32Err;
}
//
// Get the server name
//
Win32Err = NetDompGetArgumentString(rgNetDomArgs,
eCommServer,
&Server);
if ( Win32Err != ERROR_SUCCESS ) {
goto HandleQueryExit;
}
//
// Ok, make sure that we have a specified domain...
//
Win32Err = NetDompGetDomainForOperation(rgNetDomArgs,
Server,
TRUE,
&Domain);
if ( Win32Err != ERROR_SUCCESS ) {
goto HandleQueryExit;
}
//
// Get the password and user if it exists
//
if ( CmdFlagOn(rgNetDomArgs, eCommUserNameD) ) {
Win32Err = NetDompGetUserAndPasswordForOperation(rgNetDomArgs,
eCommUserNameD,
Domain,
&DomainUser);
if ( Win32Err != ERROR_SUCCESS ) {
goto HandleQueryExit;
}
}
//
// Find the query sub command.
//
NETDOM_ARG_ENUM eQuery = eArgNull;
for (int i = eQueryBegin; i <= eQueryEnd; i++)
{
if (CmdFlagOn(rgNetDomArgs, static_cast<NETDOM_ARG_ENUM>(i)))
{
if (eArgNull != eQuery)
{
ASSERT(rgNetDomArgs[i].strArg1);
NetDompDisplayUnexpectedParameter(rgNetDomArgs[i].strArg1);
DisplayHelp(ePriQuery);
Win32Err = ERROR_INVALID_PARAMETER;
goto HandleQueryExit;
}
eQuery = static_cast<NETDOM_ARG_ENUM>(i);
}
}
if (eArgNull == eQuery)
{
DisplayHelp(ePriQuery);
Win32Err = ERROR_INVALID_PARAMETER;
goto HandleQueryExit;
}
if ( CmdFlagOn(rgNetDomArgs, eCommVerify) ) {
Operation = OperationVerify;
DisplayFlag = MSG_QUERY_VERIFY;
}
if ( CmdFlagOn(rgNetDomArgs, eCommReset) ) {
if ( Operation == OperationVerify ) {
Win32Err = ERROR_INVALID_PARAMETER;
goto HandleQueryExit;
} else {
Operation = OperationReset;
DisplayFlag = MSG_QUERY_RESET;
}
}
switch (eQuery)
{
case eQueryOU:
Win32Err = NetDompQueryDisplayOus( Domain,
&DomainUser );
break;
case eQueryWksta:
Win32Err = NetDompQueryMachines( Operation,
Domain,
&DomainUser,
Server,
TypeWorkstation,
DisplayFlag ? DisplayFlag : MSG_WORKSTATION_LIST );
break;
case eQueryServer:
Win32Err = NetDompQueryMachines( Operation,
Domain,
&DomainUser,
Server,
TypeServer,
DisplayFlag ? DisplayFlag : MSG_SERVER_LIST );
break;
case eQueryDC:
Win32Err = NetDompQueryMachines( Operation,
Domain,
&DomainUser,
Server,
TypeDomainController,
DisplayFlag ? DisplayFlag : MSG_DC_LIST );
break;
case eQueryPDC:
Win32Err = NetDompQueryMachines( Operation,
Domain,
&DomainUser,
NULL,
TypePDC,
MSG_PDC_LIST );
break;
case eQueryFSMO:
Win32Err = NetDompQueryFsmo( Domain,
&DomainUser );
break;
case eQueryTrust:
if (CmdFlagOn(rgNetDomArgs, eQueryDirect) &&
CmdFlagOn(rgNetDomArgs, eCommVerify))
{
DisplayHelp(ePriQuery);
Win32Err = ERROR_INVALID_PARAMETER;
goto HandleQueryExit;
}
Win32Err = NetDompQueryTrust( Domain,
&DomainUser,
Server,
CmdFlagOn(rgNetDomArgs, eQueryDirect),
CmdFlagOn(rgNetDomArgs, eCommVerify));
break;
default:
Win32Err = ERROR_INVALID_PARAMETER;
break;
}
HandleQueryExit:
NetApiBufferFree( Domain );
NetApiBufferFree( Server );
NetDompFreeAuthIdent( &DomainUser );
if (NO_ERROR != Win32Err)
{
NetDompDisplayErrorMessage(Win32Err);
}
return( Win32Err );
}
Reference in a new issue Copy permalink