Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
NT4/private/newsam2/server/display.c
Microsoft ce47f986d8 First commit
2020-09-30 17:12:29 +02:00

5848 lines
156 KiB
C
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
display.c
Abstract:
This file contains services for maintaining the cached display
information.
The information is stored in multiple tables because there are
multiple formats it must be returned in. The tables maintained
include:
AccountsByRid - includes all user and global group accounts
by RID. Aliases may be added to this list at some time
in the future.
NormalUsersByName - Normal user accounts, sorted by name.
MachinesByName - Machine user accounts, sorted by name.
InterDomainByName - Interdomain trust accounts, sorted by
name.
GroupsByName - Global group accounts, sorted by name.
Any time an entry is placed in or removed from one of "ByName"
tables, it is also placed in or removed from the "ByRid" table.
User and machine accounts are added to the display cache in one
operation. So, there is a single boolean flag indicating whether
or not these tables are valid. The groups are maintained in a
separate table, and so there is another flag indicating whether
or not that table is valid.
The Rid table is only valid if both the group table and the
user/machine tables are valid.
Author:
Dave Chalmers (Davidc) 1-April-1992
Environment:
User Mode - Win32
Revision History:
--*/
///////////////////////////////////////////////////////////////////////////////
// //
// Includes //
// //
///////////////////////////////////////////////////////////////////////////////
#include <samsrvp.h>
///////////////////////////////////////////////////////////////////////////////
// //
// private service prototypes //
// //
///////////////////////////////////////////////////////////////////////////////
NTSTATUS
SampCreateDisplayInformation (
DOMAIN_DISPLAY_INFORMATION DisplayType
);
VOID
SampDeleteDisplayInformation (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType
);
NTSTATUS
SampRetrieveDisplayInfoFromDisk(
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType
);
NTSTATUS
SampAddDisplayAccount (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType,
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo
);
NTSTATUS
SampDeleteDisplayAccount (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType,
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo
);
NTSTATUS
SampUpdateDisplayAccount(
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType,
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo
);
NTSTATUS
SampTallyTableStatistics (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType
);
NTSTATUS
SampEmptyGenericTable2 (
PRTL_GENERIC_TABLE2 Table,
BOOLEAN FreeElements
);
PVOID
SampGenericTable2Allocate (
CLONG BufferSize
);
VOID
SampGenericTable2Free (
PVOID Buffer
);
RTL_GENERIC_COMPARE_RESULTS
SampCompareUserNodeByName (
PVOID Node1,
PVOID Node2
);
RTL_GENERIC_COMPARE_RESULTS
SampCompareMachineNodeByName ( // Also used for Interdomain trust accounts
PVOID Node1,
PVOID Node2
);
RTL_GENERIC_COMPARE_RESULTS
SampCompareGroupNodeByName (
PVOID Node1,
PVOID Node2
);
RTL_GENERIC_COMPARE_RESULTS
SampCompareNodeByRid (
PVOID Node1,
PVOID Node2
);
NTSTATUS
SampInitializeUserInfo(
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo,
PDOMAIN_DISPLAY_USER *UserInfo,
BOOLEAN CopyData
);
NTSTATUS
SampInitializeMachineInfo( // Also used for Interdomain trust accounts
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo,
PDOMAIN_DISPLAY_MACHINE *MachineInfo,
BOOLEAN CopyData
);
NTSTATUS
SampInitializeGroupInfo(
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo,
PDOMAIN_DISPLAY_GROUP *GroupInfo,
BOOLEAN CopyData
);
NTSTATUS
SampDuplicateUserInfo(
PDOMAIN_DISPLAY_USER Destination,
PDOMAIN_DISPLAY_USER Source,
ULONG Index
);
NTSTATUS
SampDuplicateMachineInfo( // Also used for Interdomain trust accounts
PDOMAIN_DISPLAY_MACHINE Destination,
PDOMAIN_DISPLAY_MACHINE Source,
ULONG Index
);
NTSTATUS
SampDuplicateGroupInfo(
PDOMAIN_DISPLAY_GROUP Destination,
PDOMAIN_DISPLAY_GROUP Source,
ULONG Index
);
NTSTATUS
SampDuplicateOemUserInfo(
PDOMAIN_DISPLAY_OEM_USER Destination,
PDOMAIN_DISPLAY_USER Source,
ULONG Index
);
NTSTATUS
SampDuplicateOemGroupInfo(
PDOMAIN_DISPLAY_OEM_GROUP Destination,
PDOMAIN_DISPLAY_GROUP Source,
ULONG Index
);
VOID
SampFreeUserInfo(
PDOMAIN_DISPLAY_USER UserInfo
);
VOID
SampFreeMachineInfo(
PDOMAIN_DISPLAY_MACHINE MachineInfo
);
VOID
SampFreeGroupInfo(
PDOMAIN_DISPLAY_GROUP GroupInfo
);
VOID
SampFreeOemUserInfo(
PDOMAIN_DISPLAY_OEM_USER UserInfo
);
VOID
SampFreeOemGroupInfo(
PDOMAIN_DISPLAY_OEM_GROUP GroupInfo
);
VOID
SampSwapUserInfo(
PDOMAIN_DISPLAY_USER Info1,
PDOMAIN_DISPLAY_USER Info2
);
VOID
SampSwapMachineInfo( // Also used for Interdomain trust accounts
PDOMAIN_DISPLAY_MACHINE Info1,
PDOMAIN_DISPLAY_MACHINE Info2
);
VOID
SampSwapGroupInfo(
PDOMAIN_DISPLAY_GROUP Info1,
PDOMAIN_DISPLAY_GROUP Info2
);
ULONG
SampBytesRequiredUserNode (
PDOMAIN_DISPLAY_USER Node
);
ULONG
SampBytesRequiredMachineNode ( // Also used for Interdomain trust accounts
PDOMAIN_DISPLAY_MACHINE Node
);
ULONG
SampBytesRequiredGroupNode (
PDOMAIN_DISPLAY_GROUP Node
);
ULONG
SampBytesRequiredOemUserNode (
PDOMAIN_DISPLAY_OEM_USER Node
);
ULONG
SampBytesRequiredOemGroupNode (
PDOMAIN_DISPLAY_OEM_GROUP Node
);
VOID
SampDisplayDiagnostic( VOID );
VOID
SampDisplayDiagEnumRids( VOID );
LONG
SampCompareDisplayStrings(
IN PUNICODE_STRING String1,
IN PUNICODE_STRING String2,
IN BOOLEAN IgnoreCase
);
//
// Macros for deciding whether an account is:
//
// A normal user account
//
// A machine account
//
// An Interdomain trust account
//
// Included in the display cache
//
//
#define USER_ACCOUNT(AccountControl) ((AccountControl & \
(USER_NORMAL_ACCOUNT | \
USER_TEMP_DUPLICATE_ACCOUNT)) != 0)
#define MACHINE_ACCOUNT(AccountControl) ((AccountControl & \
(USER_WORKSTATION_TRUST_ACCOUNT | \
USER_SERVER_TRUST_ACCOUNT)) != 0)
#define INTERDOMAIN_ACCOUNT(AccountControl) (((AccountControl) & \
(USER_INTERDOMAIN_TRUST_ACCOUNT)) != 0)
#define DISPLAY_ACCOUNT(AccountControl) (USER_ACCOUNT(AccountControl) || \
MACHINE_ACCOUNT(AccountControl) || \
INTERDOMAIN_ACCOUNT(AccountControl))
//
// Test to see if Rid table is valid
//
// BOOLEAN
// SampRidTableValid( IN ULONG DomainIndex )
//
#define SampRidTableValid(DI) ( \
(SampDefinedDomains[DI].DisplayInformation.UserAndMachineTablesValid) && \
(SampDefinedDomains[DI].DisplayInformation.GroupTableValid) \
)
///////////////////////////////////////////////////////////////////////////////
// //
// Private data types //
// //
///////////////////////////////////////////////////////////////////////////////
//
// All entries in the display cache are expected to start with this
// data structure.
//
typedef struct _SAMP_DISPLAY_ENTRY_HEADER {
//
// The index field plays two roles. Within the generic table,
// it is used to indicate which type of account this is. The
// valid types are: SAM_USER_ACCOUNT, SAM_GLOBAL_GROUP_ACCOUNT,
// or SAM_LOCAL_GROUP_ACCOUNT.
//
// Otherwise, this field is filled in just before being returned
// to query and other client calls.
//
ULONG Index;
//
// The RID of the account
//
ULONG Rid;
} SAMP_DISPLAY_ENTRY_HEADER, *PSAMP_DISPLAY_ENTRY_HEADER;
///////////////////////////////////////////////////////////////////////////////
// //
// Module-wide variables //
// //
///////////////////////////////////////////////////////////////////////////////
LCID SampSystemDefaultLCID;
///////////////////////////////////////////////////////////////////////////////
// //
// RPC exported routines //
// //
///////////////////////////////////////////////////////////////////////////////
NTSTATUS
SamrQueryDisplayInformation (
IN SAMPR_HANDLE DomainHandle,
IN DOMAIN_DISPLAY_INFORMATION DisplayInformation,
IN ULONG Index,
IN ULONG EntriesRequested,
IN ULONG PreferredMaximumLength,
OUT PULONG TotalAvailable,
OUT PULONG TotalReturned,
OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer
)
/*++
Routine Description:
Thin wrapper around SamrQueryDisplayInformation3().
Provided for compatibility with down-level clients.
--*/
{
return( SamrQueryDisplayInformation3(
DomainHandle,
DisplayInformation,
Index,
EntriesRequested,
PreferredMaximumLength,
TotalAvailable,
TotalReturned,
Buffer
) );
}
NTSTATUS
SamrQueryDisplayInformation2 (
IN SAMPR_HANDLE DomainHandle,
IN DOMAIN_DISPLAY_INFORMATION DisplayInformation,
IN ULONG Index,
IN ULONG EntriesRequested,
IN ULONG PreferredMaximumLength,
OUT PULONG TotalAvailable,
OUT PULONG TotalReturned,
OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer
)
/*++
Routine Description:
Thin wrapper around SamrQueryDisplayInformation3().
Provided for compatibility with down-level clients.
--*/
{
return( SamrQueryDisplayInformation3(
DomainHandle,
DisplayInformation,
Index,
EntriesRequested,
PreferredMaximumLength,
TotalAvailable,
TotalReturned,
Buffer
) );
}
NTSTATUS
SamrQueryDisplayInformation3 (
IN SAMPR_HANDLE DomainHandle,
IN DOMAIN_DISPLAY_INFORMATION DisplayInformation,
IN ULONG Index,
IN ULONG EntriesRequested,
IN ULONG PreferredMaximumLength,
OUT PULONG TotalAvailable,
OUT PULONG TotalReturned,
OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer
)
/*++
Routine Description:
This routine provides fast return of information commonly
needed to be displayed in user interfaces.
NT User Interface has a requirement for quick enumeration of SAM
accounts for display in list boxes. (Replication has similar but
broader requirements.)
The netui listboxes all contain similar information. e.g:
o AccountControl, the bits that identify the account type,
eg, HOME, REMOTE, SERVER, WORKSTATION, etc.
o Logon name (machine name for computers)
o Full name (not used for computers)
o Comment (admin comment for users)
SAM maintains this data locally in two sorted indexed cached
lists identified by infolevels.
o DomainDisplayUser: HOME and REMOTE user accounts only
o DomainDisplayMachine: SERVER and WORKSTATION accounts only
Note that trust accounts, groups, and aliases are not in either of
these lists.
Added for NT1.0A -
o Group enumeration has been added in NT1.0A
with the following characteristic:
We did not change the RPC interface ID. This allows
callers to continue to call down-level servers. However,
down-level servers will return an error if they passed
this information level.
o OEM string info levels were added for jimh (Chicago). These
info levels dramatically reduce the memory needed to query
the limited information that Chicago is interested in.
Parameters:
DomainHandle - A handle to an open domain for DOMAIN_LIST_ACCOUNTS.
DisplayInformation - Indicates which information is to be enumerated.
Index - The index of the first entry to be retrieved.
PreferedMaximumLength - A recommended upper limit to the number of
bytes to be returned. The returned information is allocated by
this routine.
TotalAvailable - Total number of bytes availabe in the specified info
class.
TotalReturned - Number of bytes actually returned for this call. Zero
indicates there are no entries with an index as large as that
specified.
ReturnedEntryCount - Number of entries returned by this call. Zero
indicates there are no entries with an index as large as that
specified.
Buffer - Receives a pointer to a buffer containing a (possibly)
sorted list of the requested information. This buffer is
allocated by this routine and contains the following
structure:
DomainDisplayMachine --> An array of ReturnedEntryCount elements
of type DOMAIN_DISPLAY_USER. This is
followed by the bodies of the various
strings pointed to from within the
DOMAIN_DISPLAY_USER structures.
DomainDisplayMachine --> An array of ReturnedEntryCount elements
of type DOMAIN_DISPLAY_MACHINE. This is
followed by the bodies of the various
strings pointed to from within the
DOMAIN_DISPLAY_MACHINE structures.
DomainDisplayGroup --> An array of ReturnedEntryCount elements
of type DOMAIN_DISPLAY_GROUP. This is
followed by the bodies of the various
strings pointed to from within the
DOMAIN_DISPLAY_GROUP structures.
DomainDisplayOemUser --> An array of ReturnedEntryCount elements
of type DOMAIN_DISPLAY_OEM_USER. This is
followed by the bodies of the various
strings pointed to from within the
DOMAIN_DISPLAY_OEM_user structures.
DomainDisplayOemGroup --> An array of ReturnedEntryCount elements
of type DOMAIN_DISPLAY_OEM_GROUP. This is
followed by the bodies of the various
strings pointed to from within the
DOMAIN_DISPLAY_OEM_GROUP structures.
Return Values:
STATUS_SUCCESS - normal, successful completion.
STATUS_ACCESS_DENIED - The specified handle was not opened for
the necessary access.
STATUS_INVALID_HANDLE - The specified handle is not that of an
opened Domain object.
STATUS_INVALID_INFO_CLASS - The requested class of information
is not legitimate for this service.
--*/
{
NTSTATUS
NtStatus,
IgnoreStatus;
PSAMP_OBJECT
DomainContext;
SAMP_OBJECT_TYPE
FoundType;
PSAMP_DEFINED_DOMAINS
Domain;
PSAMPR_DOMAIN_DISPLAY_USER
UserElement;
PSAMPR_DOMAIN_DISPLAY_MACHINE
MachineElement;
PSAMPR_DOMAIN_DISPLAY_GROUP
GroupElement;
ULONG
ReturnedBytes = 0,
ReturnedItems = 0;
PVOID
RestartKey;
//
// Prepare for failure
//
*TotalAvailable = 0;
*TotalReturned = 0;
switch (DisplayInformation) {
case DomainDisplayUser:
Buffer->UserInformation.EntriesRead = 0;
Buffer->UserInformation.Buffer = NULL;
break;
case DomainDisplayMachine:
Buffer->MachineInformation.EntriesRead = 0;
Buffer->MachineInformation.Buffer = NULL;
break;
case DomainDisplayGroup:
Buffer->GroupInformation.EntriesRead = 0;
Buffer->GroupInformation.Buffer = NULL;
break;
case DomainDisplayOemUser:
Buffer->OemUserInformation.EntriesRead = 0;
Buffer->OemUserInformation.Buffer = NULL;
break;
case DomainDisplayOemGroup:
Buffer->OemGroupInformation.EntriesRead = 0;
Buffer->OemGroupInformation.Buffer = NULL;
break;
default:
return(STATUS_INVALID_INFO_CLASS);
}
//
// If they don't want anything, that's what they'll get
//
if (EntriesRequested == 0) {
return(STATUS_SUCCESS);
}
//
// Make sure we don't try to allocate too much memory on
// the user's behalf
//
if (EntriesRequested > 5000) {
EntriesRequested = 5000;
}
//
// Grab the read lock
//
SampAcquireReadLock();
//
// Validate type of, and access to object.
//
DomainContext = (PSAMP_OBJECT)DomainHandle;
NtStatus = SampLookupContext(
DomainContext,
DOMAIN_LIST_ACCOUNTS,
SampDomainObjectType, // ExpectedType
&FoundType
);
if (NT_SUCCESS(NtStatus)) {
Domain = &SampDefinedDomains[ DomainContext->DomainIndex ];
//
// Set up the common loop statistics
//
ReturnedBytes = 0;
ReturnedItems = 0;
switch (DisplayInformation) {
case DomainDisplayUser:
//
// Recreate our cached data if necessary
//
NtStatus = SampCreateDisplayInformation(DomainDisplayUser);
//
// Set the Restart Key from the passed in index
//
UserElement = RtlRestartKeyByIndexGenericTable2(
&Domain->DisplayInformation.UserTable,
Index,
&RestartKey
);
if (UserElement == NULL) {
NtStatus = STATUS_SUCCESS;
Buffer->GroupInformation.EntriesRead = 0;
*TotalReturned = 0;
*TotalAvailable = 0; // Not supported for this info level
break; // out of switch
}
//
// Allocate space for array of elements
//
Buffer->UserInformation.Buffer = MIDL_user_allocate(
EntriesRequested * sizeof(SAMPR_DOMAIN_DISPLAY_USER));
if (Buffer->UserInformation.Buffer == NULL) {
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
break; // out of switch
}
//
// Prepare default return value
//
NtStatus = STATUS_MORE_ENTRIES;
//
// Increment the index value for assignment in our return
// buffer
//
Index++;
do {
NTSTATUS TempStatus;
//
// Store a copy of this element in the return buffer.
//
TempStatus = SampDuplicateUserInfo(
(PDOMAIN_DISPLAY_USER)
&(Buffer->UserInformation.Buffer[ReturnedItems]),
(PDOMAIN_DISPLAY_USER)UserElement,
Index);
Index++;
if (!NT_SUCCESS(TempStatus)) {
//
// Free up everything we've allocated so far
//
while(ReturnedItems > 0) {
ReturnedItems --;
SampFreeUserInfo((PDOMAIN_DISPLAY_USER)
&(Buffer->UserInformation.Buffer[ReturnedItems]));
}
MIDL_user_free(Buffer->UserInformation.Buffer);
Buffer->UserInformation.Buffer = NULL;
NtStatus = TempStatus;
break; // out of do loop
}
//
// Update loop statistics
//
ReturnedBytes += SampBytesRequiredUserNode(
(PDOMAIN_DISPLAY_USER)UserElement);
ReturnedItems ++;
//
// Go find the next element
//
UserElement = RtlEnumerateGenericTable2(
&Domain->DisplayInformation.UserTable,
&RestartKey
);
if (UserElement == NULL) {
NtStatus = STATUS_SUCCESS;
break; // out of do loop
}
} while ( (ReturnedBytes < PreferredMaximumLength) &&
(ReturnedItems < EntriesRequested) );
//
// Update output parameters
//
if (NT_SUCCESS(NtStatus)) {
Buffer->UserInformation.EntriesRead = ReturnedItems;
*TotalReturned = ReturnedBytes;
*TotalAvailable = Domain->DisplayInformation.TotalBytesInUserTable;
}
break; // out of switch
case DomainDisplayMachine:
//
// Recreate our cached data if necessary
//
NtStatus = SampCreateDisplayInformation(DomainDisplayMachine);
//
// Set the Restart Key from the passed in index
//
MachineElement = RtlRestartKeyByIndexGenericTable2(
&Domain->DisplayInformation.MachineTable,
Index,
&RestartKey
);
if (MachineElement == NULL) {
NtStatus = STATUS_SUCCESS;
Buffer->GroupInformation.EntriesRead = 0;
*TotalReturned = 0;
*TotalAvailable = 0; // Not supported for this info level
break; // out of switch
}
//
// Allocate space for array of elements
//
Buffer->MachineInformation.Buffer = MIDL_user_allocate(
EntriesRequested * sizeof(SAMPR_DOMAIN_DISPLAY_MACHINE));
if (Buffer->MachineInformation.Buffer == NULL) {
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
break; // out of switch
}
//
// Prepare default return value
//
NtStatus = STATUS_MORE_ENTRIES;
//
// Increment the index value for assignment in our return
// buffer
//
Index++;
do {
NTSTATUS TempStatus;
//
// Store a copy of this element in the return buffer.
//
TempStatus = SampDuplicateMachineInfo(
(PDOMAIN_DISPLAY_MACHINE)
&(Buffer->MachineInformation.Buffer[ReturnedItems]),
(PDOMAIN_DISPLAY_MACHINE)MachineElement,
Index);
Index++;
if (!NT_SUCCESS(TempStatus)) {
//
// Free up everything we've allocated so far
//
while(ReturnedItems > 0) {
ReturnedItems--;
SampFreeMachineInfo((PDOMAIN_DISPLAY_MACHINE)
&(Buffer->MachineInformation.Buffer[ReturnedItems]));
}
MIDL_user_free(Buffer->MachineInformation.Buffer);
Buffer->MachineInformation.Buffer = NULL;
NtStatus = TempStatus;
break; // out of do loop
}
//
// Update loop statistics
//
ReturnedBytes += SampBytesRequiredMachineNode(
(PDOMAIN_DISPLAY_MACHINE)MachineElement);
ReturnedItems ++;
//
// Go find the next element
//
MachineElement = RtlEnumerateGenericTable2(
&Domain->DisplayInformation.MachineTable,
&RestartKey
);
if (MachineElement == NULL) {
NtStatus = STATUS_SUCCESS;
break; // out of do loop
}
} while ( (ReturnedBytes < PreferredMaximumLength) &&
(ReturnedItems < EntriesRequested) );
//
// Update output parameters
//
if (NT_SUCCESS(NtStatus)) {
Buffer->MachineInformation.EntriesRead = ReturnedItems;
*TotalReturned = ReturnedBytes;
*TotalAvailable = Domain->DisplayInformation.TotalBytesInMachineTable;
}
break; // out of switch
case DomainDisplayGroup:
//
// Recreate our cached data if necessary
//
NtStatus = SampCreateDisplayInformation(DomainDisplayGroup);
//
// Set the Restart Key from the passed in index
//
GroupElement = RtlRestartKeyByIndexGenericTable2(
&Domain->DisplayInformation.GroupTable,
Index,
&RestartKey
);
if (GroupElement == NULL) {
NtStatus = STATUS_SUCCESS;
Buffer->GroupInformation.EntriesRead = 0;
*TotalReturned = 0;
*TotalAvailable = 0; // Not supported for this info level
break; // out of switch
}
//
// Allocate space for array of elements
//
Buffer->GroupInformation.Buffer = MIDL_user_allocate(
EntriesRequested * sizeof(SAMPR_DOMAIN_DISPLAY_GROUP));
if (Buffer->GroupInformation.Buffer == NULL) {
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
break; // out of switch
}
//
// Prepare default return value
//
NtStatus = STATUS_MORE_ENTRIES;
//
// Increment the index value for assignment in our return
// buffer
//
Index++;
do {
NTSTATUS TempStatus;
//
// Store a copy of this element in the return buffer.
//
TempStatus = SampDuplicateGroupInfo(
(PDOMAIN_DISPLAY_GROUP)
&(Buffer->GroupInformation.Buffer[ReturnedItems]),
(PDOMAIN_DISPLAY_GROUP)GroupElement,
Index);
Index++;
if (!NT_SUCCESS(TempStatus)) {
//
// Free up everything we've allocated so far
//
while(ReturnedItems > 0) {
ReturnedItems--;
SampFreeGroupInfo((PDOMAIN_DISPLAY_GROUP)
&(Buffer->GroupInformation.Buffer[ReturnedItems]));
}
MIDL_user_free(Buffer->GroupInformation.Buffer);
Buffer->GroupInformation.Buffer = NULL;
NtStatus = TempStatus;
break; // out of do loop
}
//
// Update loop statistics
//
ReturnedBytes += SampBytesRequiredGroupNode(
(PDOMAIN_DISPLAY_GROUP)GroupElement);
ReturnedItems ++;
//
// Go find the next element
//
GroupElement = RtlEnumerateGenericTable2(
&Domain->DisplayInformation.GroupTable,
&RestartKey
);
if (GroupElement == NULL) {
NtStatus = STATUS_SUCCESS;
break; // out of do loop
}
} while ( (ReturnedBytes < PreferredMaximumLength) &&
(ReturnedItems < EntriesRequested) );
//
// Update output parameters
//
if (NT_SUCCESS(NtStatus)) {
Buffer->GroupInformation.EntriesRead = ReturnedItems;
*TotalReturned = ReturnedBytes;
*TotalAvailable = Domain->DisplayInformation.TotalBytesInGroupTable;
}
break; // out of switch
case DomainDisplayOemUser:
//
// Recreate our cached data if necessary
//
NtStatus = SampCreateDisplayInformation(DomainDisplayUser);
//
// Set the Restart Key from the passed in index
//
UserElement = RtlRestartKeyByIndexGenericTable2(
&Domain->DisplayInformation.UserTable,
Index,
&RestartKey
);
if (UserElement == NULL) {
NtStatus = STATUS_SUCCESS;
Buffer->GroupInformation.EntriesRead = 0;
*TotalReturned = 0;
*TotalAvailable = 0; // Not supported for this info level
break; // out of switch
}
//
// Allocate space for array of elements
//
Buffer->UserInformation.Buffer = MIDL_user_allocate(
EntriesRequested * sizeof(SAMPR_DOMAIN_DISPLAY_OEM_USER));
if (Buffer->OemUserInformation.Buffer == NULL) {
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
break; // out of switch
}
//
// Prepare default return value
//
NtStatus = STATUS_MORE_ENTRIES;
//
// Increment the index value for assignment in our return
// buffer
//
Index++;
do {
NTSTATUS TempStatus;
//
// Store a copy of this element in the return buffer.
//
TempStatus = SampDuplicateOemUserInfo(
(PDOMAIN_DISPLAY_OEM_USER)
&(Buffer->OemUserInformation.Buffer[ReturnedItems]),
(PDOMAIN_DISPLAY_USER)UserElement,
Index);
Index++;
if (!NT_SUCCESS(TempStatus)) {
//
// Free up everything we've allocated so far
//
while(ReturnedItems > 0) {
ReturnedItems --;
SampFreeOemUserInfo((PDOMAIN_DISPLAY_OEM_USER)
&(Buffer->UserInformation.Buffer[ReturnedItems]));
}
MIDL_user_free(Buffer->OemUserInformation.Buffer);
Buffer->OemUserInformation.Buffer = NULL;
NtStatus = TempStatus;
break; // out of do loop
}
//
// Update loop statistics
//
ReturnedBytes +=
SampBytesRequiredOemUserNode(
(PDOMAIN_DISPLAY_OEM_USER)
&(Buffer->OemUserInformation.Buffer[ReturnedItems]));
ReturnedItems ++;
//
// Go find the next element
//
UserElement = RtlEnumerateGenericTable2(
&Domain->DisplayInformation.UserTable,
&RestartKey
);
if (UserElement == NULL) {
NtStatus = STATUS_SUCCESS;
break; // out of do loop
}
} while ( (ReturnedBytes < PreferredMaximumLength) &&
(ReturnedItems < EntriesRequested) );
//
// Update output parameters
//
if (NT_SUCCESS(NtStatus)) {
Buffer->UserInformation.EntriesRead = ReturnedItems;
*TotalReturned = ReturnedBytes;
*TotalAvailable = 0; // Not supported for this info level
}
break; // out of switch
case DomainDisplayOemGroup:
//
// Recreate our cached data if necessary
//
NtStatus = SampCreateDisplayInformation(DomainDisplayGroup);
//
// Set the Restart Key from the passed in index
//
GroupElement = RtlRestartKeyByIndexGenericTable2(
&Domain->DisplayInformation.GroupTable,
Index,
&RestartKey
);
if (GroupElement == NULL) {
NtStatus = STATUS_SUCCESS;
Buffer->GroupInformation.EntriesRead = 0;
*TotalReturned = 0;
*TotalAvailable = 0; // Not supported for this info level
break; // out of switch
}
//
// Allocate space for array of elements
//
Buffer->GroupInformation.Buffer = MIDL_user_allocate(
EntriesRequested * sizeof(SAMPR_DOMAIN_DISPLAY_OEM_GROUP));
if (Buffer->OemGroupInformation.Buffer == NULL) {
NtStatus = STATUS_INSUFFICIENT_RESOURCES;
break; // out of switch
}
//
// Prepare default return value
//
NtStatus = STATUS_MORE_ENTRIES;
//
// Increment the index value for assignment in our return
// buffer
//
Index++;
do {
NTSTATUS TempStatus;
//
// Store a copy of this element in the return buffer.
//
TempStatus = SampDuplicateOemGroupInfo(
(PDOMAIN_DISPLAY_OEM_GROUP)
&(Buffer->OemGroupInformation.Buffer[ReturnedItems]),
(PDOMAIN_DISPLAY_GROUP)GroupElement,
Index);
Index++;
if (!NT_SUCCESS(TempStatus)) {
//
// Free up everything we've allocated so far
//
while(ReturnedItems > 0) {
ReturnedItems --;
SampFreeOemGroupInfo((PDOMAIN_DISPLAY_OEM_GROUP)
&(Buffer->GroupInformation.Buffer[ReturnedItems]));
}
MIDL_user_free(Buffer->OemGroupInformation.Buffer);
Buffer->OemGroupInformation.Buffer = NULL;
NtStatus = TempStatus;
break; // out of do loop
}
//
// Update loop statistics
//
ReturnedBytes +=
SampBytesRequiredOemGroupNode(
(PDOMAIN_DISPLAY_OEM_GROUP)
&(Buffer->OemGroupInformation.Buffer[ReturnedItems]));
ReturnedItems ++;
//
// Go find the next element
//
GroupElement = RtlEnumerateGenericTable2(
&Domain->DisplayInformation.GroupTable,
&RestartKey
);
if (GroupElement == NULL) {
NtStatus = STATUS_SUCCESS;
break; // out of do loop
}
} while ( (ReturnedBytes < PreferredMaximumLength) &&
(ReturnedItems < EntriesRequested) );
//
// Update output parameters
//
if (NT_SUCCESS(NtStatus)) {
Buffer->GroupInformation.EntriesRead = ReturnedItems;
*TotalReturned = ReturnedBytes;
*TotalAvailable = 0; // Not supported for this info level
}
break; // out of switch
}
//
// De-reference the object
//
IgnoreStatus = SampDeReferenceContext( DomainContext, FALSE);
ASSERT(NT_SUCCESS(IgnoreStatus));
}
//
// Free the read lock
//
SampReleaseReadLock();
return(NtStatus);
}
NTSTATUS
SamrGetDisplayEnumerationIndex (
IN SAMPR_HANDLE DomainHandle,
IN DOMAIN_DISPLAY_INFORMATION DisplayInformation,
IN PRPC_UNICODE_STRING Prefix,
OUT PULONG Index
)
/*++
Routine Description:
This wrapper around SamrGetDisplayEnumerationIndex2().
Provided for compatibility with down-level clients.
--*/
{
return(SamrGetDisplayEnumerationIndex2( DomainHandle,
DisplayInformation,
Prefix,
Index
) );
}
NTSTATUS
SamrGetDisplayEnumerationIndex2 (
IN SAMPR_HANDLE DomainHandle,
IN DOMAIN_DISPLAY_INFORMATION DisplayInformation,
IN PRPC_UNICODE_STRING Prefix,
OUT PULONG Index
)
/*++
Routine Description:
This routine returns the index of the entry which alphabetically
immediatly preceeds a specified prefix. If no such entry exists,
then zero is returned as the index.
Parameters:
DomainHandle - A handle to an open domain for DOMAIN_LIST_ACCOUNTS.
DisplayInformation - Indicates which sorted information class is
to be searched.
Prefix - The prefix to compare.
Index - Receives the index of the entry of the information class
with a LogonName (or MachineName) which immediatly preceeds the
provided prefix string. If there are no elements which preceed
the prefix, then zero is returned.
Return Values:
STATUS_SUCCESS - normal, successful completion.
STATUS_ACCESS_DENIED - The specified handle was not opened for
the necessary access.
STATUS_INVALID_HANDLE - The specified handle is not that of an
opened Domain object.
STATUS_NO_MORE_ENTRIES - There are no entries for this information class.
--*/
{
NTSTATUS
NtStatus,
IgnoreStatus;
PSAMP_OBJECT
DomainContext;
SAMP_OBJECT_TYPE
FoundType;
PSAMP_DEFINED_DOMAINS
Domain;
PRTL_GENERIC_TABLE2
Table;
DOMAIN_DISPLAY_USER
UserElement;
DOMAIN_DISPLAY_MACHINE
MachineElement;
DOMAIN_DISPLAY_GROUP
GroupElement;
RTL_GENERIC_COMPARE_RESULTS
CompareResult;
PRTL_GENERIC_2_COMPARE_ROUTINE
CompareRoutine;
PVOID
Element,
NextElement,
RestartKey;
ULONG
CurrentIndex;
//
// Check the information class
//
if ((DisplayInformation != DomainDisplayUser) &&
(DisplayInformation != DomainDisplayMachine) &&
(DisplayInformation != DomainDisplayGroup)
) {
return(STATUS_INVALID_INFO_CLASS);
}
//
// Grab the read lock
//
SampAcquireReadLock();
//
// Validate type of, and access to object.
//
DomainContext = (PSAMP_OBJECT)DomainHandle;
NtStatus = SampLookupContext(
DomainContext,
DOMAIN_LIST_ACCOUNTS,
SampDomainObjectType, // ExpectedType
&FoundType
);
if (NT_SUCCESS(NtStatus)) {
Domain = &SampDefinedDomains[ DomainContext->DomainIndex ];
//
// Set default return value
//
(*Index) = 0;
//
// Recreate our cached data if necessary
//
NtStatus = SampCreateDisplayInformation(DisplayInformation);
if (NT_SUCCESS(NtStatus)) {
//
// Set up
// The table to search,
// The comparison routine to use,
// An appropriate element for the search.
//
switch (DisplayInformation) {
case DomainDisplayUser:
Table = &Domain->DisplayInformation.UserTable;
CompareRoutine = SampCompareUserNodeByName;
Element = (PVOID)&UserElement;
UserElement.LogonName = *(PUNICODE_STRING)Prefix;
break; // out of switch
case DomainDisplayMachine:
Table = &Domain->DisplayInformation.MachineTable;
CompareRoutine = SampCompareMachineNodeByName;
Element = (PVOID)&MachineElement;
MachineElement.Machine = *(PUNICODE_STRING)Prefix;
break; // out of switch
case DomainDisplayGroup:
Table = &Domain->DisplayInformation.GroupTable;
CompareRoutine = SampCompareGroupNodeByName;
Element = (PVOID)&GroupElement;
GroupElement.Group = *(PUNICODE_STRING)Prefix;
break; // out of switch
}
if (RtlIsGenericTable2Empty(Table)) {
NtStatus = STATUS_NO_MORE_ENTRIES;
} else {
//
// Now compare each entry until we find the one asked
// for.
//
CurrentIndex = 0;
RestartKey = NULL;
for (NextElement = RtlEnumerateGenericTable2(Table, &RestartKey);
NextElement != NULL;
NextElement = RtlEnumerateGenericTable2(Table, &RestartKey)) {
//
// Compare with passed in element
//
CompareResult = (*CompareRoutine)( NextElement, Element );
if (CompareResult != GenericLessThan) {
break; // break out of for loop
}
CurrentIndex++;
}
//
// CurrentIndex has the return value in it.
//
ASSERT( CurrentIndex <= RtlNumberElementsGenericTable2(Table) );
(*Index) = CurrentIndex;
NtStatus = STATUS_SUCCESS;
}
}
//
// De-reference the object
//
IgnoreStatus = SampDeReferenceContext( DomainContext, FALSE);
ASSERT(NT_SUCCESS(IgnoreStatus));
}
//
// Free the read lock
//
SampReleaseReadLock();
return(NtStatus);
}
///////////////////////////////////////////////////////////////////////////////
// //
// Routines available to trusted clients in SAM's process //
// //
///////////////////////////////////////////////////////////////////////////////
NTSTATUS
SamIEnumerateAccountRids(
IN SAMPR_HANDLE DomainHandle,
IN ULONG AccountTypesMask,
IN ULONG StartingRid,
IN ULONG PreferedMaximumLength,
OUT PULONG ReturnCount,
OUT PULONG *AccountRids
)
/*++
Routine Description:
Provide a list of account RIDs. The caller may ask for one or
more types of account rids in a single call.
The returned rids are in ascending value order.
WARNING - This routine is only callable by trusted clients.
Therefore, parameter checking is only performed
in checked-build systems.
Parameters:
DomainHandle - handle to the domain whose accounts are to be
enumerated.
AccountTypesMask - Mask indicating which types of accounts
the caller wants enumerated. These included:
SAM_USER_ACCOUNT
SAM_GLOBAL_GROUP_ACCOUNT
SAM_LOCAL_GROUP_ACCOUNT (not yet supported)
StartingRid - A rid that is less than the lowest value rid to be
included in the enumeration.
PreferedMaximumLength - Provides a restriction on how much memory
may be returned in this call. This is not a hard upper limit,
but serves as a guideline.
ReturnCount - Receives a count of the number of rids returned.
AccountRids - Receives a pointer to an array of rids. If
ReturnCount is zero, then this will be returned as NULL.
Otherwise, it will point to an array containing ReturnCount
rids.
Return Values:
STATUS_SUCCESS - The Service completed successfully, and there
are no additional entries.
STATUS_MORE_ENTRIES - There are more entries, so call again.
This is a successful return.
STATUS_INVALID_INFO_CLASS - The specified AccountTypesMask contained
unknown or unsupported account types.
STATUS_NO_MEMORY - Could not allocate pool to complete the call.
--*/
{
NTSTATUS
NtStatus,
IgnoreStatus;
PSAMP_OBJECT
DomainContext;
SAMP_OBJECT_TYPE
FoundType;
PSAMP_DEFINED_DOMAINS
Domain;
PRTL_GENERIC_TABLE2
Table;
ULONG
MaxEntries,
Count,
AccountType;
PVOID
RestartKey;
PSAMP_DISPLAY_ENTRY_HEADER
Element;
SAMP_DISPLAY_ENTRY_HEADER
RestartValue;
//
// Prepare for failure
//
(*ReturnCount) = 0;
(*AccountRids) = NULL;
#if DBG
if ( (AccountTypesMask & ~( SAM_USER_ACCOUNT | SAM_GLOBAL_GROUP_ACCOUNT))
!= 0 ) {
return(STATUS_INVALID_INFO_CLASS);
}
#endif //DBG
//
// Grab the read lock
//
SampAcquireReadLock();
//
// Validate type of, and access to object.
//
DomainContext = (PSAMP_OBJECT)DomainHandle;
NtStatus = SampLookupContext(
DomainContext,
0, // Trusted clients only
SampDomainObjectType, // ExpectedType
&FoundType
);
if (NT_SUCCESS(NtStatus)) {
Domain = &SampDefinedDomains[ DomainContext->DomainIndex ];
Table = &Domain->DisplayInformation.RidTable;
//
// If the RID table isn't valid, force it to be made valid.
//
if (!SampRidTableValid(DomainContext->DomainIndex)) {
NtStatus = SampCreateDisplayInformation ( DomainDisplayUser ); //User and machine
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampCreateDisplayInformation ( DomainDisplayGroup );
}
}
if (NT_SUCCESS(NtStatus)) {
//
// Allocate a return buffer.
// Only allocate as much as we can use.
// This is limited either by PreferedMaximumLength
// or the number of entries in the table.
//
MaxEntries =
( PreferedMaximumLength / sizeof(ULONG) );
if (MaxEntries == 0) {
MaxEntries = 1; // Always return at least one
}
if (MaxEntries > RtlNumberElementsGenericTable2(Table) ) {
MaxEntries = RtlNumberElementsGenericTable2(Table);
}
PreferedMaximumLength = MaxEntries *
sizeof(SAMP_DISPLAY_ENTRY_HEADER);
(*AccountRids) = MIDL_user_allocate( PreferedMaximumLength );
if ((*AccountRids) == NULL) {
STATUS_NO_MEMORY;
}
//
// Get the restart key based upon the passed in RID.
//
Table = &Domain->DisplayInformation.RidTable;
RestartValue.Rid = StartingRid;
Element = RtlRestartKeyByValueGenericTable2(
Table,
&RestartValue,
&RestartKey
);
//
// Now we may loop obtaining entries until we reach
// either MaxEntries or the end of the table.
//
// WARNING - there is one special case that we have to
// take care of. If the returned Element is not null,
// but the RestartKey is null, then the caller has
// asked for an enumeration and passed in the last rid
// defined. If we aren't careful, this will cause an
// enumeration to be started from the beginning of the
// list again. Instead, return status indicating we have
// no more entries.
//
Count = 0;
if (((Element != NULL) && (RestartKey == NULL))) {
Element = NULL; // Used to signify no more entries found
} else {
for (Element = RtlEnumerateGenericTable2(Table, &RestartKey);
( (Element != NULL) && (Count < MaxEntries) );
Element = RtlEnumerateGenericTable2(Table, &RestartKey)) {
//
// Make sure this is an account that was asked for
//
AccountType = Element->Index;
if ((AccountType & AccountTypesMask) != 0) {
(*AccountRids)[Count] = Element->Rid;
Count++;
}
}
}
//
// Now figure out what we have done:
//
// Returned all entries in table => STATUS_SUCCESS
// More entries to return => STATUS_MORE_ENTRIES
//
// Count == 0 => free AccountRid array.
//
if (Element == NULL) {
NtStatus = STATUS_SUCCESS;
} else {
NtStatus = STATUS_MORE_ENTRIES;
}
if (Count == 0) {
MIDL_user_free( (*AccountRids) );
(*AccountRids) = NULL;
}
(*ReturnCount) = Count;
}
//
// De-reference the object
//
IgnoreStatus = SampDeReferenceContext( DomainContext, FALSE);
ASSERT(NT_SUCCESS(IgnoreStatus));
}
//
// Free the read lock
//
SampReleaseReadLock();
return(NtStatus);
}
///////////////////////////////////////////////////////////////////////////////
// //
// Routines available to other SAM modules //
// //
///////////////////////////////////////////////////////////////////////////////
NTSTATUS
SampInitializeDisplayInformation (
ULONG DomainIndex
)
/*++
Routine Description:
This routines initializes the display information structure.
This involves initializing the User, Machine and Group trees (empty),
and setting the Valid flag to FALSE.
If this is the account domain, we also create the display information.
Parameters:
DomainIndex - An index into the DefinedDomains array. This array
contains information about the domain being openned,
including its name.
Return Values:
STATUS_SUCCESS - normal, successful completion.
--*/
{
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation;
//
// This must be initialized before we use SampCompareDisplayStrings().
//
SampSystemDefaultLCID = GetSystemDefaultLCID();
DisplayInformation = &SampDefinedDomains[DomainIndex].DisplayInformation;
RtlInitializeGenericTable2(
&DisplayInformation->UserTable,
SampCompareUserNodeByName,
SampGenericTable2Allocate,
SampGenericTable2Free);
RtlInitializeGenericTable2(
&DisplayInformation->MachineTable,
SampCompareMachineNodeByName,
SampGenericTable2Allocate,
SampGenericTable2Free);
RtlInitializeGenericTable2(
&DisplayInformation->InterdomainTable,
SampCompareMachineNodeByName,
SampGenericTable2Allocate,
SampGenericTable2Free);
RtlInitializeGenericTable2(
&DisplayInformation->GroupTable,
SampCompareGroupNodeByName,
SampGenericTable2Allocate,
SampGenericTable2Free);
RtlInitializeGenericTable2(
&DisplayInformation->RidTable,
SampCompareNodeByRid,
SampGenericTable2Allocate,
SampGenericTable2Free);
DisplayInformation->UserAndMachineTablesValid = FALSE;
DisplayInformation->GroupTableValid = FALSE;
if ( SampProductType == NtProductLanManNt &&
DomainIndex == SampDefinedDomainsCount - 1 ) {
//
// Grab the read lock and indicate which domain the transaction is in
//
SampAcquireReadLock();
SampSetTransactionDomain( DomainIndex );
//
// Populate the Display Cache
//
SAMTRACE("MURLI.... WE DIE HERE");
(VOID) SampCreateDisplayInformation(DomainDisplayUser);
(VOID) SampCreateDisplayInformation(DomainDisplayGroup);
SAMTRACE("MURLI.... NOPE WE SURVIVED");
//
// Free the read lock
//
SampReleaseReadLock();
}
return(STATUS_SUCCESS);
}
VOID
SampDeleteDisplayInformation (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType
)
/*++
Routine Description:
This routines frees up any resources used by the display information.
Note: It use to be that we could selectively invalidate
portions of the display cache (e.g., users, or groups).
With the addition of the RID table, this becomes
problematic. So, now the approach is to flush all tables
for a domain if any the tables in that domain are flushed.
Parameters:
DisplayInformation - The display information structure to delete.
ObjectType - Indicates which table to delete the information from.
Return Values:
STATUS_SUCCESS - normal, successful completion.
--*/
{
NTSTATUS NtStatus;
//
// Empty the user table and check it really is empty
//
NtStatus = SampEmptyGenericTable2(&DisplayInformation->UserTable, FALSE);
ASSERT(NT_SUCCESS(NtStatus));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->UserTable));
DisplayInformation->TotalBytesInUserTable = 0;
//
// Empty the machine table and check it really is empty
//
NtStatus = SampEmptyGenericTable2(&DisplayInformation->MachineTable, FALSE);
ASSERT(NT_SUCCESS(NtStatus));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->MachineTable));
DisplayInformation->TotalBytesInMachineTable = 0;
//
// Empty the Interdomain table and check it really is empty
//
NtStatus = SampEmptyGenericTable2(&DisplayInformation->InterdomainTable, FALSE);
ASSERT(NT_SUCCESS(NtStatus));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->InterdomainTable));
DisplayInformation->TotalBytesInInterdomainTable = 0;
//
// Empty the Group table and check it really is empty
//
NtStatus = SampEmptyGenericTable2(&DisplayInformation->GroupTable, FALSE);
ASSERT(NT_SUCCESS(NtStatus));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->GroupTable));
DisplayInformation->TotalBytesInGroupTable = 0;
//
// Empty the Rid table and check it really is empty.
//
NtStatus = SampEmptyGenericTable2(&DisplayInformation->RidTable, FALSE);
ASSERT(NT_SUCCESS(NtStatus));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->RidTable));
DisplayInformation->TotalBytesInRidTable = 0;
}
NTSTATUS
SampMarkDisplayInformationInvalid (
SAMP_OBJECT_TYPE ObjectType
)
/*++
Routine Description:
This routine invalidates any cached display information. This
causes it to be recreated the next time a client queries it.
Later we will probably start/restart a thread here and have it
re-create the display information in the background.
Note: THIS ROUTINE REFERENCES THE CURRENT TRANSACTION DOMAIN
(ESTABLISHED USING SampSetTransactioDomain()). THIS
SERVICE MAY ONLY BE CALLED AFTER SampSetTransactionDomain()
AND BEFORE SampReleaseWriteLock().
Another Note: It use to be that we could selectively invalidate
portions of the display cache (e.g., users, or groups).
With the addition of the RID table, this becomes
problematic. So, now the approach is to flush all tables
for a domain if any the tables in that domain are flushed.
Parameters:
ObjectType - SampUserObjectType or SampGroupObjectType. Only the
appropriate tables will be marked Invalid. For User type, the
user and machine tables will be marked Invalid. For Group type,
the group table will be marked Invalid.
Return Values:
STATUS_SUCCESS - normal, successful completion.
--*/
{
PSAMP_DEFINED_DOMAINS Domain;
ASSERT(SampTransactionWithinDomain == TRUE);
SampDiagPrint(DISPLAY_CACHE,
("SAM: MarkDisplayInformationInvalid : Emptying cache\n"));
//
// Get pointer to the current domain structure
//
Domain = &SampDefinedDomains[SampTransactionDomainIndex];
//
// Delete any cached data
//
SampDeleteDisplayInformation(&Domain->DisplayInformation, ObjectType);
//
// Set the Valid flag to FALSE
//
Domain->DisplayInformation.UserAndMachineTablesValid = FALSE;
Domain->DisplayInformation.GroupTableValid = FALSE;
return(STATUS_SUCCESS);
}
NTSTATUS
SampCreateDisplayInformation (
DOMAIN_DISPLAY_INFORMATION DisplayType
)
/*++
Routine Description:
This routine builds the cached display information for the current
domain.
Note: THIS ROUTINE REFERENCES THE CURRENT TRANSACTION DOMAIN
(ESTABLISHED USING SampSetTransactioDomain()). THIS
SERVICE MAY ONLY BE CALLED AFTER SampSetTransactionDomain()
AND BEFORE SampReleaseReadLock().
Parameters:
DisplayType - Indicates which type of display information is
being created. This leads us to the appropriate table(s).
Return Values:
STATUS_SUCCESS - normal, successful completion.
--*/
{
NTSTATUS NtStatus;
PSAMP_DEFINED_DOMAINS Domain;
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation;
SAMTRACE("SampCreateDisplayInformation");
ASSERT(SampTransactionWithinDomain == TRUE);
Domain = &SampDefinedDomains[SampTransactionDomainIndex];
DisplayInformation = &Domain->DisplayInformation;
switch (DisplayType) {
case DomainDisplayUser:
case DomainDisplayMachine:
//
// If the cache is valid, nothing to do
//
if (DisplayInformation->UserAndMachineTablesValid) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: CreateDisplayInformation : User/Machine Cache is valid, nothing to do\n"));
return(STATUS_SUCCESS);
};
SampDiagPrint(DISPLAY_CACHE,
("SAM: CreateDisplayInformation : Creating user/machine cache...\n"));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->UserTable));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->MachineTable));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->InterdomainTable));
NtStatus = SampRetrieveDisplayInfoFromDisk( DisplayInformation, SampUserObjectType );
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampTallyTableStatistics(DisplayInformation, SampUserObjectType);
}
//
// Clean up on error
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: CreateDisplayInformation FAILED: 0x%lx\n", NtStatus));
SampDeleteDisplayInformation(&Domain->DisplayInformation, SampUserObjectType);
} else {
Domain->DisplayInformation.UserAndMachineTablesValid = TRUE;
}
break; // out of switch
case DomainDisplayGroup:
//
// If the cache is valid, nothing to do
//
if (DisplayInformation->GroupTableValid) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: CreateDisplayInformation : Group Cache is valid, nothing to do\n"));
return(STATUS_SUCCESS);
};
SampDiagPrint(DISPLAY_CACHE,
("SAM: CreateDisplayInformation : Creating group cache...\n"));
ASSERT(RtlIsGenericTable2Empty(&DisplayInformation->GroupTable));
NtStatus = SampRetrieveDisplayInfoFromDisk( DisplayInformation, SampGroupObjectType );
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampTallyTableStatistics(DisplayInformation, SampGroupObjectType);
}
//
// Clean up on error
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: CreateDisplayInformation FAILED: 0x%lx\n", NtStatus));
SampDeleteDisplayInformation(&Domain->DisplayInformation, SampGroupObjectType);
} else {
Domain->DisplayInformation.GroupTableValid = TRUE;
}
break; // out of switch
}
return(NtStatus);
}
NTSTATUS
SampRetrieveDisplayInfoFromDisk(
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType
)
{
NTSTATUS NtStatus;
SAM_ENUMERATE_HANDLE EnumerationContext;
PSAMPR_ENUMERATION_BUFFER EnumerationBuffer;
ULONG i;
ULONG CountReturned;
BOOLEAN MoreEntries;
SAMTRACE("SampRetrieveDisplayInfoFromDisk");
//
// Enumerate the accounts.
// For each account, get the relevant information on it,
// and add to either the UserTable, MachineTable, or GroupTable.
//
EnumerationContext = 0;
do {
NtStatus = SampEnumerateAccountNames(
ObjectType,
&EnumerationContext,
&EnumerationBuffer,
200000, // PreferedMaximumLength
0L, // no filter
&CountReturned,
FALSE // trusted client
);
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: Retrieve Info From Disk - "
"Error enumerating account names (0x%lx)\n",
NtStatus) );
break;
}
//
// Make a note if there are more entries
//
MoreEntries = (NtStatus == STATUS_MORE_ENTRIES);
//
// For each account, get the necessary information for it
// and add to the appropriate display information table
//
for (i = 0; i < EnumerationBuffer->EntriesRead; i++) {
ULONG AccountRid =
EnumerationBuffer->Buffer[i].RelativeId;
PUNICODE_STRING AccountName =
(PUNICODE_STRING)&(EnumerationBuffer->Buffer[i].Name);
SAMP_V1_0A_FIXED_LENGTH_USER UserV1aFixed; // Contains account control
SAMP_V1_0A_FIXED_LENGTH_GROUP GroupV1Fixed; // Contains attributes
SAMP_ACCOUNT_DISPLAY_INFO AccountInfo;
PSAMP_OBJECT AccountContext;
//
// Open a context to the account
//
NtStatus = SampCreateAccountContext(
ObjectType,
AccountRid,
TRUE, // Trusted client
TRUE, // Account exists
&AccountContext
);
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: Retrieve Info From Disk - "
"Error Creating account context (0x%lx)\n",
NtStatus) );
break; // out of for loop
}
//
// Get the account control information
//
switch (ObjectType) {
case SampUserObjectType:
NtStatus = SampRetrieveUserV1aFixed(AccountContext, &UserV1aFixed);
if (!NT_SUCCESS(NtStatus)) {
SampDeleteContext( AccountContext );
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: Retrieve USER From Disk - "
"Error getting V1a Fixed (0x%lx)\n",
NtStatus) );
break; // out of for loop
}
//
// If this is not an account we're interested in skip it
//
if (!DISPLAY_ACCOUNT(UserV1aFixed.UserAccountControl)) {
SampDeleteContext( AccountContext );
continue; // next account
}
//
// Get the admin comment
//
NtStatus = SampGetUnicodeStringAttribute(
AccountContext,
SAMP_USER_ADMIN_COMMENT,
FALSE, // Don't make copy
&AccountInfo.Comment
);
if (!NT_SUCCESS(NtStatus)) {
SampDeleteContext( AccountContext );
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: Retrieve USER From Disk - "
"Error getting admin comment (0x%lx)\n",
NtStatus) );
break; // out of for loop
}
//
// Get the full name
//
NtStatus = SampGetUnicodeStringAttribute(
AccountContext,
SAMP_USER_FULL_NAME,
FALSE, // Don't make copy
&AccountInfo.FullName
);
if (!NT_SUCCESS(NtStatus)) {
SampDeleteContext( AccountContext );
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: Retrieve USER From Disk - "
"Error getting full name (0x%lx)\n",
NtStatus) );
break; // out of for loop
}
//
// Set the account control
//
AccountInfo.AccountControl = UserV1aFixed.UserAccountControl;
break; // out of switch
case SampGroupObjectType:
NtStatus = SampRetrieveGroupV1Fixed(AccountContext, &GroupV1Fixed);
if (!NT_SUCCESS(NtStatus)) {
SampDeleteContext( AccountContext );
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: Retrieve GROUP From Disk - "
"Error getting V1 fixed (0x%lx)\n",
NtStatus) );
break; // out of for loop
}
//
// Get the admin comment
//
NtStatus = SampGetUnicodeStringAttribute(
AccountContext,
SAMP_GROUP_ADMIN_COMMENT,
FALSE, // Don't make copy
&AccountInfo.Comment
);
if (!NT_SUCCESS(NtStatus)) {
SampDeleteContext( AccountContext );
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: Retrieve GROUP From Disk - "
"Error getting admin comment (0x%lx)\n",
NtStatus) );
break; // out of for loop
}
//
// Set the attributes
//
AccountInfo.AccountControl = GroupV1Fixed.Attributes;
break; // out of switch
}
//
// Now add this account to the cached data
//
AccountInfo.Rid = AccountRid;
AccountInfo.Name = *((PUNICODE_STRING)(&EnumerationBuffer->Buffer[i].Name));
NtStatus = SampAddDisplayAccount(DisplayInformation,
ObjectType,
&AccountInfo);
//
// We're finished with the account context
//
SampDeleteContext( AccountContext );
//
// Check the result of adding the account to the cache
//
if (!NT_SUCCESS(NtStatus)) {
break; // out of for loop
}
} // end_for
//
// Free up the enumeration buffer returned
//
SamIFree_SAMPR_ENUMERATION_BUFFER(EnumerationBuffer);
} while ( MoreEntries );
return(NtStatus);
}
NTSTATUS
SampUpdateDisplayInformation (
PSAMP_ACCOUNT_DISPLAY_INFO OldAccountInfo OPTIONAL,
PSAMP_ACCOUNT_DISPLAY_INFO NewAccountInfo OPTIONAL,
SAMP_OBJECT_TYPE ObjectType
)
/*++
Routine Description:
This routines updates the cached display information to reflect
changes to a single account.
If any error occurs, this routine marks the cached information
Invalid so it will get fixed during re-creation.
Note: THIS ROUTINE REFERENCES THE CURRENT TRANSACTION DOMAIN
(ESTABLISHED USING SampSetTransactioDomain()). THIS
SERVICE MAY ONLY BE CALLED AFTER SampSetTransactionDomain()
AND BEFORE SampReleaseWriteLock().
Parameters:
OldAccountInfo - The old information for this account. If this is NULL
then the account is being added.
The only fields required in the OldAccountInfo are
Name
AccountControl
Rid
NewAccountInfo - The new information for this account. If this is NULL
then the account is being deleted.
ObjectType - Indicates whether the account is a user account or
group account.
Return Values:
STATUS_SUCCESS - normal, successful completion.
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
PSAMP_DEFINED_DOMAINS Domain;
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation;
BOOLEAN DoUpdate;
ASSERT( ARGUMENT_PRESENT(OldAccountInfo) ||
ARGUMENT_PRESENT(NewAccountInfo)
);
ASSERT(SampTransactionWithinDomain == TRUE);
Domain = &SampDefinedDomains[SampTransactionDomainIndex];
DisplayInformation = &Domain->DisplayInformation;
IF_SAMP_GLOBAL( DISPLAY_CACHE ) {
if (ARGUMENT_PRESENT(OldAccountInfo) && ARGUMENT_PRESENT(NewAccountInfo)) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayInformation : Updating cache for old account <%wZ>, new <%wZ>\n",
&OldAccountInfo->Name, &NewAccountInfo->Name));
}
if (!ARGUMENT_PRESENT(OldAccountInfo) && ARGUMENT_PRESENT(NewAccountInfo)) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayInformation : Adding account <%wZ> to cache\n",
&NewAccountInfo->Name));
}
if (ARGUMENT_PRESENT(OldAccountInfo) && !ARGUMENT_PRESENT(NewAccountInfo)) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayInformation : Deleting account <%wZ> from cache\n",
&OldAccountInfo->Name));
}
} //end_IF_SAMP_GLOBAL
switch (ObjectType) {
case SampUserObjectType:
//
// If the cache is Invalid there's nothing to do
//
if (!DisplayInformation->UserAndMachineTablesValid) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayInformation : User Cache is Invalid, nothing to do\n"));
return(STATUS_SUCCESS);
};
//
// If this is an update to an existing account then try
// to do an inplace update of the cache.
// If this fails because it's too complex etc, then revert to
// the less efficient method of deleting the old, then adding the new.
//
DoUpdate = FALSE;
if (ARGUMENT_PRESENT(OldAccountInfo) && ARGUMENT_PRESENT(NewAccountInfo)) {
//
// We can only do an update if both old and new accounts
// are types that we keep in the display cache.
//
if ( DISPLAY_ACCOUNT(OldAccountInfo->AccountControl) &&
DISPLAY_ACCOUNT(NewAccountInfo->AccountControl) ) {
//
// We can only do an update if the account is still of
// the same type. i.e. it hasn't jumped cache table.
//
if ( (USER_ACCOUNT(OldAccountInfo->AccountControl) ==
USER_ACCOUNT(NewAccountInfo->AccountControl)) &&
(MACHINE_ACCOUNT(OldAccountInfo->AccountControl) ==
MACHINE_ACCOUNT(NewAccountInfo->AccountControl)) ) {
//
// We can only do an update if the account name hasn't changed
//
if (RtlEqualUnicodeString( &OldAccountInfo->Name,
&NewAccountInfo->Name,
FALSE // Case sensitive
)) {
//
// Everything has been checked out - we can do an update
//
DoUpdate = TRUE;
}
}
}
}
break; // out of switch
case SampGroupObjectType:
//
// If the cache is already Invalid there's nothing to do
//
if (!DisplayInformation->GroupTableValid) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayInformation : Group Cache is Invalid, nothing to do\n"));
return(STATUS_SUCCESS);
};
//
// If this is an update to an existing account then try
// and do an inplace update of the cache.
// If this fails because it's too complex etc, then revert to
// the less efficient method of deleting the old, then adding the new.
//
DoUpdate = FALSE;
if (ARGUMENT_PRESENT(OldAccountInfo) && ARGUMENT_PRESENT(NewAccountInfo)) {
//
// We can only do an update if the account name hasn't changed
//
if (RtlEqualUnicodeString( &OldAccountInfo->Name,
&NewAccountInfo->Name,
FALSE // Case sensitive
)) {
DoUpdate = TRUE;
}
}
break; // out of switch
}
//
// Do an update if possible, otherwise do delete then insert
//
if (DoUpdate) {
NtStatus = SampUpdateDisplayAccount(DisplayInformation,
ObjectType,
NewAccountInfo);
} else {
NtStatus = STATUS_SUCCESS;
//
// Delete the old account
//
if (ARGUMENT_PRESENT(OldAccountInfo)) {
NtStatus = SampDeleteDisplayAccount(DisplayInformation,
ObjectType,
OldAccountInfo);
}
//
// Add the new account
//
if (NT_SUCCESS(NtStatus) && ARGUMENT_PRESENT(NewAccountInfo)) {
NtStatus = SampAddDisplayAccount(DisplayInformation,
ObjectType,
NewAccountInfo);
}
//
// Re-tally the cache
//
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampTallyTableStatistics(DisplayInformation, ObjectType);
}
}
if (!NT_SUCCESS(NtStatus)) {
//
// Something screwed up.
// Mark the cache Invalid - it will get rebuilt from scratch
// at the next query.
//
KdPrint(("SAM: The display cache is inconsistent, forcing rebuild\n"));
ASSERT(FALSE);
NtStatus = SampMarkDisplayInformationInvalid(ObjectType);
ASSERT(NT_SUCCESS(NtStatus));
NtStatus = STATUS_SUCCESS;
}
return(NtStatus);
}
///////////////////////////////////////////////////////////////////////////////
// //
// Routines available within this module only //
// //
///////////////////////////////////////////////////////////////////////////////
NTSTATUS
SampDeleteDisplayAccount (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType,
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo
)
/*++
Routine Description:
This routines deletes the specified account from the cached display
information. It is asummed that if this account is a cached type it
will appear in the appropriate cache table.
Parameters:
DisplayInformation - Pointer to cached display information
ObjectType - Indicates which table(s) to look for the account in.
AccountInfo - The account to be deleted.
Return Values:
STATUS_SUCCESS - normal, successful completion.
STATUS_INTERNAL_ERROR - the account is a cached type yet could not be
found in the cached data.
--*/
{
NTSTATUS NtStatus;
ULONG Control = AccountInfo->AccountControl;
BOOLEAN Success;
//
// We expect the cache to be valid
//
#if DBG
switch (ObjectType) {
case SampUserObjectType:
ASSERT(DisplayInformation->UserAndMachineTablesValid);
break; //out of switch
case SampGroupObjectType:
ASSERT(DisplayInformation->GroupTableValid);
break; //out of switch
}
#endif //DBG
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Deleting account <%wZ>\n", &AccountInfo->Name));
switch (ObjectType) {
case SampUserObjectType:
if (USER_ACCOUNT(Control)) {
DOMAIN_DISPLAY_USER LocalUserInfo;
PDOMAIN_DISPLAY_USER UserInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Deleting account from user table\n"));
UserInfo = &LocalUserInfo;
NtStatus = SampInitializeUserInfo(AccountInfo, &UserInfo, FALSE);
if (NT_SUCCESS(NtStatus)) {
//
// Delete the account from the user table
//
Success = RtlDeleteElementGenericTable2(
&DisplayInformation->UserTable,
(PVOID)UserInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from user table\n"));
ASSERT(FALSE);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now remove it to the RID table
//
(VOID)RtlDeleteElementGenericTable2(
&DisplayInformation->RidTable,
(PVOID)UserInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from RID table\n"));
NtStatus = STATUS_INTERNAL_ERROR;
ASSERT(Success);
}
}
}
} else if (MACHINE_ACCOUNT(Control)) {
DOMAIN_DISPLAY_MACHINE LocalMachineInfo;
PDOMAIN_DISPLAY_MACHINE MachineInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Deleting account from machine table\n"));
MachineInfo = &LocalMachineInfo;
NtStatus = SampInitializeMachineInfo(AccountInfo, &MachineInfo, FALSE);
if (NT_SUCCESS(NtStatus)) {
//
// Delete the account from the machine table
//
Success = RtlDeleteElementGenericTable2(
&DisplayInformation->MachineTable,
(PVOID)MachineInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from machine table\n"));
ASSERT(FALSE);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now remove it to the RID table
//
Success = RtlDeleteElementGenericTable2(
&DisplayInformation->RidTable,
(PVOID)MachineInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from RID table\n"));
NtStatus = STATUS_INTERNAL_ERROR;
ASSERT(Success);
}
}
}
} else if (INTERDOMAIN_ACCOUNT(Control)) {
//
// Interdomain account
//
DOMAIN_DISPLAY_MACHINE LocalInterdomainInfo;
PDOMAIN_DISPLAY_MACHINE InterdomainInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Deleting account from Interdomain table\n"));
InterdomainInfo = &LocalInterdomainInfo;
NtStatus = SampInitializeMachineInfo(AccountInfo, &InterdomainInfo, FALSE);
if (NT_SUCCESS(NtStatus)) {
//
// Delete the account from the Interdomain table
//
Success = RtlDeleteElementGenericTable2(
&DisplayInformation->InterdomainTable,
(PVOID)InterdomainInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from Interdomain table\n"));
ASSERT(FALSE);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now remove it to the RID table
//
Success = RtlDeleteElementGenericTable2(
&DisplayInformation->RidTable,
(PVOID)InterdomainInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from RID table\n"));
NtStatus = STATUS_INTERNAL_ERROR;
ASSERT(Success);
}
}
}
} else {
//
// This account is not one that we cache - nothing to do
//
NtStatus = STATUS_SUCCESS;
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Account is not one that we cache, account control = 0x%lx\n", Control));
}
break; //out of switch
case SampGroupObjectType:
{
DOMAIN_DISPLAY_GROUP LocalGroupInfo;
PDOMAIN_DISPLAY_GROUP GroupInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Deleting account from Group table\n"));
GroupInfo = &LocalGroupInfo;
NtStatus = SampInitializeGroupInfo(AccountInfo, &GroupInfo, FALSE);
if (NT_SUCCESS(NtStatus)) {
//
// Delete the account from the Group table
//
Success = RtlDeleteElementGenericTable2(
&DisplayInformation->GroupTable,
(PVOID)GroupInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from Group table\n"));
ASSERT(FALSE);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now remove it to the RID table
//
(VOID)RtlDeleteElementGenericTable2(
&DisplayInformation->RidTable,
(PVOID)GroupInfo);
if (!Success) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: DeleteDisplayAccount : Failed to delete element from RID table\n"));
NtStatus = STATUS_INTERNAL_ERROR;
ASSERT(Success);
}
}
}
break; //out of switch
}
}
return(STATUS_SUCCESS);
}
NTSTATUS
SampAddDisplayAccount (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType,
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo
)
/*++
Routine Description:
This routines adds the specified account to the cached display
information as appropriate to its type.
Parameters:
DisplayInformation - Pointer to cached display information
ObjectType - SampUserObjectType or SampGroupObjectType. Helps
determine which table it goes into.
AccountInfo - The account to be added.
Return Values:
STATUS_SUCCESS - normal, successful completion.
STATUS_INTERNAL_ERROR - the account already existed in the cache
--*/
{
NTSTATUS
NtStatus;
ULONG
Control = AccountInfo->AccountControl;
BOOLEAN
NewElement;
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Adding account <%wZ>\n", &AccountInfo->Name));
if (ObjectType == SampGroupObjectType) {
PDOMAIN_DISPLAY_GROUP GroupInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Adding account to group table\n"));
NtStatus = SampInitializeGroupInfo(AccountInfo, &GroupInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
//
// Add the account to the Group table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->GroupTable,
GroupInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: AddDisplayAccount : Account already exists in GROUP table\n"));
ASSERT(FALSE);
SampFreeGroupInfo(GroupInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now add it to the RID table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->RidTable,
GroupInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: AddDisplayAccount : Account already exists in RID table\n"));
NtStatus = STATUS_INTERNAL_ERROR;
ASSERT(NewElement);
}
}
}
} else {
ASSERT(ObjectType == SampUserObjectType);
if (USER_ACCOUNT(Control)) {
PDOMAIN_DISPLAY_USER UserInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Adding account to user table\n"));
NtStatus = SampInitializeUserInfo(AccountInfo, &UserInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
//
// Add the account to the normal user table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->UserTable,
UserInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: AddDisplayAccount : Account already exists in USER table\n"));
ASSERT(FALSE);
SampFreeUserInfo(UserInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now add it to the RID table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->RidTable,
UserInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: AddDisplayAccount : Account already exists in RID table\n"));
ASSERT(NewElement);
NtStatus = STATUS_INTERNAL_ERROR;
}
}
}
} else if (MACHINE_ACCOUNT(Control)) {
PDOMAIN_DISPLAY_MACHINE MachineInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Adding account to machine table\n"));
NtStatus = SampInitializeMachineInfo(AccountInfo, &MachineInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
//
// Add the account to the machine table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->MachineTable,
MachineInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Account already exists in MACHINE table\n"));
ASSERT(FALSE);
SampFreeMachineInfo(MachineInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now add it to the RID table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->RidTable,
MachineInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Account already exists in RID table\n"));
ASSERT(NewElement);
NtStatus = STATUS_INTERNAL_ERROR;
}
}
}
} else if (INTERDOMAIN_ACCOUNT(Control)) {
PDOMAIN_DISPLAY_MACHINE InterdomainInfo;
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Adding account to Interdomain table\n"));
NtStatus = SampInitializeMachineInfo(AccountInfo, &InterdomainInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
//
// Add the account to the Interdomain table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->InterdomainTable,
InterdomainInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Account already exists in Interdomain table\n"));
ASSERT(FALSE);
SampFreeMachineInfo(InterdomainInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// Now add it to the RID table
//
(VOID)RtlInsertElementGenericTable2(
&DisplayInformation->RidTable,
InterdomainInfo,
&NewElement);
if (!NewElement) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Account already exists in RID table\n"));
ASSERT(NewElement);
NtStatus = STATUS_INTERNAL_ERROR;
}
}
}
} else {
//
// This account is not one that we cache - nothing to do
//
SampDiagPrint(DISPLAY_CACHE,
("SAM: AddDisplayAccount : Account is not one that we cache, account control = 0x%lx\n", Control));
NtStatus = STATUS_SUCCESS;
}
}
return(NtStatus);
}
NTSTATUS
SampUpdateDisplayAccount(
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType,
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo
)
/*++
Routine Description:
This routines attempts to update an account in the display cache.
Note: THIS ROUTINE REFERENCES THE CURRENT TRANSACTION DOMAIN
(ESTABLISHED USING SampSetTransactioDomain()). THIS
SERVICE MAY ONLY BE CALLED AFTER SampSetTransactionDomain()
AND BEFORE SampReleaseWriteLock().
Parameters:
DisplayInformation - Pointer to cached display information
ObjectType - Indicates whether the account is a user account or
group account.
AccountInfo - The new information for this account.
Return Values:
STATUS_SUCCESS - normal, successful completion.
Notes:
The account must be a cached type (MACHINE/USER/GROUP)
--*/
{
NTSTATUS NtStatus;
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayAccount : Updating cached account <%wZ>\n",
&AccountInfo->Name));
#if SAMP_DIAGNOSTICS
{
UNICODE_STRING
SampDiagAccountName;
RtlInitUnicodeString( &SampDiagAccountName, L"SAMP_DIAG" );
if (RtlEqualUnicodeString(&AccountInfo->Name, &SampDiagAccountName, FALSE)) {
SampDisplayDiagnostic();
}
}
#endif //SAMP_DIAGNOSTICS
//
// We should only be called when the cache is valid.
//
switch (ObjectType) {
case SampUserObjectType:
ASSERT(DisplayInformation->UserAndMachineTablesValid);
//
// The account must be one that we cache
//
ASSERT( DISPLAY_ACCOUNT(AccountInfo->AccountControl) );
//
// Go find the account in the appropriate table and update it's fields.
//
if (USER_ACCOUNT(AccountInfo->AccountControl)) {
PDOMAIN_DISPLAY_USER UserInfo;
//
// Allocate space for and initialize the new data
//
NtStatus = SampInitializeUserInfo(AccountInfo, &UserInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
PDOMAIN_DISPLAY_USER FoundElement;
//
// Search for the account in the user table
//
FoundElement = RtlLookupElementGenericTable2(
&DisplayInformation->UserTable,
UserInfo);
if (FoundElement == NULL) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayAccount : Account <%wZ> not found in user table\n", &AccountInfo->Name));
ASSERT(FALSE);
SampFreeUserInfo(UserInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// We found it. Check the old and new match where we expect.
// Can't change either the logon name or RID by this routine.
//
ASSERT(RtlEqualUnicodeString(&FoundElement->LogonName, &UserInfo->LogonName, FALSE));
ASSERT(FoundElement->Rid == UserInfo->Rid);
//
// Free up the existing data in the account element
// (all the strings) and replace it with the new data.
// Don't worry about the index value. It isn't
// valid in the table.
//
SampSwapUserInfo(FoundElement, UserInfo);
SampFreeUserInfo(UserInfo);
}
}
} else if (MACHINE_ACCOUNT(AccountInfo->AccountControl)) {
PDOMAIN_DISPLAY_MACHINE MachineInfo;
//
// Allocate space for and initialize the new data
//
NtStatus = SampInitializeMachineInfo(AccountInfo, &MachineInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
PDOMAIN_DISPLAY_MACHINE FoundElement;
//
// Search for the account in the user table
//
FoundElement = RtlLookupElementGenericTable2(
&DisplayInformation->MachineTable,
MachineInfo);
if (FoundElement == NULL) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayAccount : Account <%wZ> not found in machine table\n", &AccountInfo->Name));
ASSERT(FALSE);
SampFreeMachineInfo(MachineInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// We found it. Check the old and new match where we expect.
// Can't change either the account name or RID by this routine.
//
ASSERT(RtlEqualUnicodeString(&FoundElement->Machine, &MachineInfo->Machine, FALSE));
ASSERT(FoundElement->Rid == MachineInfo->Rid);
//
// Free up the existing data in the account element
// (all the strings) and replace it with the new data.
// Don't worry about the index value. It isn't
// valid in the table.
//
SampSwapMachineInfo(FoundElement, MachineInfo);
SampFreeMachineInfo(MachineInfo);
}
}
} else if (INTERDOMAIN_ACCOUNT(AccountInfo->AccountControl)) {
PDOMAIN_DISPLAY_MACHINE InterdomainInfo;
//
// Allocate space for and initialize the new data
//
NtStatus = SampInitializeMachineInfo(AccountInfo, &InterdomainInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
PDOMAIN_DISPLAY_MACHINE FoundElement;
//
// Search for the account in the user table
//
FoundElement = RtlLookupElementGenericTable2(
&DisplayInformation->InterdomainTable,
InterdomainInfo);
if (FoundElement == NULL) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayAccount : Account <%wZ> not found in Interdomain table\n", &AccountInfo->Name));
ASSERT(FALSE);
SampFreeMachineInfo(InterdomainInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// We found it. Check the old and new match where we expect.
// Can't change either the account name or RID by this routine.
//
ASSERT(RtlEqualUnicodeString(&FoundElement->Machine, &InterdomainInfo->Machine, FALSE));
ASSERT(FoundElement->Rid == InterdomainInfo->Rid);
//
// Free up the existing data in the account element
// (all the strings) and replace it with the new data.
// Don't worry about the index value. It isn't
// valid in the table.
//
SampSwapMachineInfo(FoundElement, InterdomainInfo);
SampFreeMachineInfo(InterdomainInfo);
}
}
}
break; // out of switch
case SampGroupObjectType:
{
PDOMAIN_DISPLAY_GROUP GroupInfo;
ASSERT(DisplayInformation->GroupTableValid);
//
// Allocate space for and initialize the new data
//
NtStatus = SampInitializeGroupInfo(AccountInfo, &GroupInfo, TRUE);
if (NT_SUCCESS(NtStatus)) {
PDOMAIN_DISPLAY_GROUP FoundElement;
//
// Search for the account in the group table
//
FoundElement = RtlLookupElementGenericTable2(
&DisplayInformation->GroupTable,
GroupInfo);
if (FoundElement == NULL) {
SampDiagPrint(DISPLAY_CACHE,
("SAM: UpdateDisplayAccount : Account <%wZ> not found in group table\n", &AccountInfo->Name));
ASSERT(FALSE);
SampFreeGroupInfo(GroupInfo);
NtStatus = STATUS_INTERNAL_ERROR;
} else {
//
// We found it. Check the old and new match where we expect.
// Can't change either the account name or RID by this routine.
//
ASSERT(RtlEqualUnicodeString(&FoundElement->Group, &GroupInfo->Group, FALSE));
ASSERT(FoundElement->Rid == GroupInfo->Rid);
//
// Free up the existing data in the account element
// (all the strings) and replace it with the new data.
// Don't worry about the index value. It isn't
// valid in the table.
//
SampSwapGroupInfo(FoundElement, GroupInfo);
SampFreeGroupInfo(GroupInfo);
}
}
}
break; // out of switch
} // end_switch
return(NtStatus);
}
NTSTATUS
SampTallyTableStatistics (
PSAMP_DOMAIN_DISPLAY_INFORMATION DisplayInformation,
SAMP_OBJECT_TYPE ObjectType
)
/*++
Routine Description:
This routines runs through the cached data tables and totals
up the number of bytes in all elements of each table and stores
in the displayinfo.
Parameters:
DisplayInformation - The display information structure to tally.
ObjectType - Indicates which table(s) to tally.
Return Values:
STATUS_SUCCESS - normal, successful completion.
--*/
{
PVOID Node;
PVOID RestartKey;
switch (ObjectType) {
case SampUserObjectType:
DisplayInformation->TotalBytesInUserTable = 0;
RestartKey = NULL;
for (Node = RtlEnumerateGenericTable2( &DisplayInformation->UserTable,
&RestartKey);
Node != NULL;
Node = RtlEnumerateGenericTable2( &DisplayInformation->UserTable,
&RestartKey)
) {
DisplayInformation->TotalBytesInUserTable +=
SampBytesRequiredUserNode((PDOMAIN_DISPLAY_USER)Node);
}
DisplayInformation->TotalBytesInMachineTable = 0;
RestartKey = NULL;
for (Node = RtlEnumerateGenericTable2( &DisplayInformation->MachineTable,
&RestartKey);
Node != NULL;
Node = RtlEnumerateGenericTable2( &DisplayInformation->MachineTable,
&RestartKey)
) {
DisplayInformation->TotalBytesInMachineTable +=
SampBytesRequiredMachineNode((PDOMAIN_DISPLAY_MACHINE)Node);
}
break; // out of switch
case SampGroupObjectType:
DisplayInformation->TotalBytesInGroupTable = 0;
RestartKey = NULL;
for (Node = RtlEnumerateGenericTable2( &DisplayInformation->GroupTable,
&RestartKey);
Node != NULL;
Node = RtlEnumerateGenericTable2( &DisplayInformation->GroupTable,
&RestartKey)
) {
DisplayInformation->TotalBytesInGroupTable +=
SampBytesRequiredGroupNode((PDOMAIN_DISPLAY_GROUP)Node);
}
break; // out of switch
} // end_switch
return(STATUS_SUCCESS);
}
NTSTATUS
SampEmptyGenericTable2 (
PRTL_GENERIC_TABLE2 Table,
BOOLEAN FreeElements
)
/*++
Routine Description:
This routines deletes all elements in the specified table.
Parameters:
Table - The table whose elements are to be deleted.
FreeElements - Indicates whether or not the element bodies
should also be freed.
Return Values:
STATUS_SUCCESS - normal, successful completion.
--*/
{
BOOLEAN Deleted;
PVOID Element;
ULONG RestartKey;
RestartKey = 0; // Always get the first element
while ((Element = RtlEnumerateGenericTable2( Table, (PVOID *)&RestartKey)) != NULL) {
Deleted = RtlDeleteElementGenericTable2(Table, Element);
ASSERT(Deleted);
if (FreeElements) {
MIDL_user_free( Element );
}
RestartKey = 0;
}
return(STATUS_SUCCESS);
}
NTSTATUS
SampInitializeUserInfo(
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo,
PDOMAIN_DISPLAY_USER *UserInfo,
BOOLEAN CopyData
)
/*++
Routine Description:
This routines initializes the passed user info structure from the
AccountInfo parameter.
Parameters:
AccountInfo - The account information
UserInfo - Pointer to the pointer to the user structure to initialize.
If CopyData is TRUE, then a pointer to the user structure will be
returned to this argument.
CopyData - FALSE - the UserInfo structure points to the same data as
the AccountInfo structure
TRUE - space for the data is allocated and all data copied
out of the AccountInfo structure into it.
Return Values:
STATUS_SUCCESS - UserInfo initialized successfully.
STATUS_NO_MEMORY - Heap could not be allocated to copy the data.
--*/
{
NTSTATUS
NtStatus;
PDOMAIN_DISPLAY_USER
UI;
if (CopyData) {
(*UserInfo) = MIDL_user_allocate( sizeof(DOMAIN_DISPLAY_USER) );
if ((*UserInfo) == NULL) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: Init User Info: failed to allocate %d bytes\n",
sizeof(DOMAIN_DISPLAY_USER)) );
return(STATUS_NO_MEMORY);
}
}
UI = (*UserInfo);
UI->Rid = AccountInfo->Rid;
UI->AccountControl = AccountInfo->AccountControl;
if (CopyData) {
//
// Set all strings to NULL initially
//
RtlInitUnicodeString(&UI->LogonName, NULL);
RtlInitUnicodeString(&UI->AdminComment, NULL);
RtlInitUnicodeString(&UI->FullName, NULL);
//
// Copy source data into destination
//
NtStatus = SampDuplicateUnicodeString(&UI->LogonName,
&AccountInfo->Name);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&UI->AdminComment,
&AccountInfo->Comment);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&UI->FullName,
&AccountInfo->FullName);
}
}
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampInitializeUserInfo failed, status = 0x%lx\n", NtStatus));
SampFreeUserInfo(UI);
}
} else {
//
// Refer to source data directly
//
UI->LogonName = AccountInfo->Name;
UI->AdminComment = AccountInfo->Comment;
UI->FullName = AccountInfo->FullName;
NtStatus = STATUS_SUCCESS;
}
//
// In the Generic Table, the Index field is used to tag the type
// of account so we can filter enumerations.
//
UI->Index = SAM_USER_ACCOUNT;
return(NtStatus);
}
NTSTATUS
SampInitializeMachineInfo(
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo,
PDOMAIN_DISPLAY_MACHINE *MachineInfo,
BOOLEAN CopyData
)
/*++
Routine Description:
This routines initializes the passed machine info structure from the
AccountInfo parameter.
Parameters:
AccountInfo - The account information
MachineInfo - Pointer to the pointer to the Machine structure to initialize.
If CopyData is TRUE, then a pointer to the structure will be
returned to this argument.
CopyData - FALSE - the MachineInfo structure points to the same data as
the AccountInfo structure
TRUE - space for the data is allocated and all data copied
out of the AccountInfo structure into it.
Return Values:
STATUS_SUCCESS - UserInfo initialized successfully.
--*/
{
NTSTATUS
NtStatus;
PDOMAIN_DISPLAY_MACHINE
MI;
if (CopyData) {
(*MachineInfo) = MIDL_user_allocate( sizeof(DOMAIN_DISPLAY_MACHINE) );
if ((*MachineInfo) == NULL) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: Init Mach Info: failed to allocate %d bytes\n",
sizeof(DOMAIN_DISPLAY_MACHINE)) );
return(STATUS_NO_MEMORY);
}
}
MI = (*MachineInfo);
MI->Rid = AccountInfo->Rid;
MI->AccountControl = AccountInfo->AccountControl;
if (CopyData) {
//
// Set all strings to NULL initially
//
RtlInitUnicodeString(&MI->Machine, NULL);
RtlInitUnicodeString(&MI->Comment, NULL);
//
// Copy source data into destination
//
NtStatus = SampDuplicateUnicodeString(&MI->Machine,
&AccountInfo->Name);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&MI->Comment,
&AccountInfo->Comment);
}
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampInitializeMachineInfo failed, status = 0x%lx\n", NtStatus));
SampFreeMachineInfo(MI);
}
} else {
//
// Refer to source data directly
//
MI->Machine = AccountInfo->Name;
MI->Comment = AccountInfo->Comment;
NtStatus = STATUS_SUCCESS;
}
//
// In the Generic Table, the Index field is used to tag the type
// of account so we can filter enumerations.
//
MI->Index = SAM_USER_ACCOUNT;
return(NtStatus);
}
NTSTATUS
SampInitializeGroupInfo(
PSAMP_ACCOUNT_DISPLAY_INFO AccountInfo,
PDOMAIN_DISPLAY_GROUP *GroupInfo,
BOOLEAN CopyData
)
/*++
Routine Description:
This routines initializes the passed Group info structure from the
AccountInfo parameter.
Parameters:
AccountInfo - The account information
GroupInfo - Pointer to the pointer to the Group structure to initialize.
If CopyData is TRUE, then a pointer to the structure will be
returned to this argument.
CopyData - FALSE - the GroupInfo structure points to the same data as
the AccountInfo structure
TRUE - space for the data is allocated and all data copied
out of the AccountInfo structure into it.
Return Values:
STATUS_SUCCESS - GroupInfo initialized successfully.
--*/
{
NTSTATUS
NtStatus;
PDOMAIN_DISPLAY_GROUP
GI;
if (CopyData) {
(*GroupInfo) = MIDL_user_allocate( sizeof(DOMAIN_DISPLAY_GROUP) );
if ((*GroupInfo) == NULL) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: Init Group Info: failed to allocate %d bytes\n",
sizeof(DOMAIN_DISPLAY_GROUP)) );
return(STATUS_NO_MEMORY);
}
}
GI = (*GroupInfo);
GI->Rid = AccountInfo->Rid;
GI->Attributes = AccountInfo->AccountControl;
if (CopyData) {
//
// Set all strings to NULL initially
//
RtlInitUnicodeString(&GI->Group, NULL);
RtlInitUnicodeString(&GI->Comment, NULL);
//
// Copy source data into destination
//
NtStatus = SampDuplicateUnicodeString(&GI->Group,
&AccountInfo->Name);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&GI->Comment,
&AccountInfo->Comment);
}
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampInitializeGroupInfo failed, status = 0x%lx\n", NtStatus));
SampFreeGroupInfo(GI);
}
} else {
//
// Refer to source data directly
//
GI->Group = AccountInfo->Name;
GI->Comment = AccountInfo->Comment;
NtStatus = STATUS_SUCCESS;
}
//
// In the Generic Table, the Index field is used to tag the type
// of account so we can filter enumerations.
//
GI->Index = SAM_GLOBAL_GROUP_ACCOUNT;
return(NtStatus);
}
NTSTATUS
SampDuplicateUserInfo(
PDOMAIN_DISPLAY_USER Destination,
PDOMAIN_DISPLAY_USER Source,
ULONG Index
)
/*++
Routine Description:
This routine allocates space in the destination and copies over the
data from the source into it.
Parameters:
Destination - The structure to copy data into
Source - The structure containing the data to copy
Index - This value will be placed in the destination's Index
field.
Return Values:
STATUS_SUCCESS - Destination contains a duplicate of the source data.
--*/
{
NTSTATUS NtStatus;
Destination->Index = Index;
Destination->Rid = Source->Rid;
Destination->AccountControl = Source->AccountControl;
//
// Set all strings to NULL initially
//
RtlInitUnicodeString(&Destination->LogonName, NULL);
RtlInitUnicodeString(&Destination->AdminComment, NULL);
RtlInitUnicodeString(&Destination->FullName, NULL);
//
// Copy source data into destination
//
NtStatus = SampDuplicateUnicodeString(&Destination->LogonName,
&Source->LogonName);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&Destination->AdminComment,
&Source->AdminComment);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&Destination->FullName,
&Source->FullName);
}
}
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampDuplicateUserInfo failed, status = 0x%lx\n", NtStatus));
SampFreeUserInfo(Destination);
}
return(NtStatus);
}
NTSTATUS
SampDuplicateMachineInfo(
PDOMAIN_DISPLAY_MACHINE Destination,
PDOMAIN_DISPLAY_MACHINE Source,
ULONG Index
)
/*++
Routine Description:
This routine allocates space in the destination and copies over the
data from the source into it.
Parameters:
Destination - The structure to copy data into
Source - The structure containing the data to copy
Index - This value will be placed in the destination's Index
field.
Return Values:
STATUS_SUCCESS - Destination contains a duplicate of the source data.
--*/
{
NTSTATUS NtStatus;
Destination->Index = Index;
Destination->Rid = Source->Rid;
Destination->AccountControl = Source->AccountControl;
//
// Set all strings to NULL initially
//
RtlInitUnicodeString(&Destination->Machine, NULL);
RtlInitUnicodeString(&Destination->Comment, NULL);
//
// Copy source data into destination
//
NtStatus = SampDuplicateUnicodeString(&Destination->Machine,
&Source->Machine);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&Destination->Comment,
&Source->Comment);
}
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampDuplicateMachineInfo failed, status = 0x%lx\n", NtStatus));
SampFreeMachineInfo(Destination);
}
return(NtStatus);
}
NTSTATUS
SampDuplicateGroupInfo(
PDOMAIN_DISPLAY_GROUP Destination,
PDOMAIN_DISPLAY_GROUP Source,
ULONG Index
)
/*++
Routine Description:
This routine allocates space in the destination and copies over the
data from the source into it.
Parameters:
Destination - The structure to copy data into
Source - The structure containing the data to copy
Index - This value will be placed in the destination's Index
field.
Return Values:
STATUS_SUCCESS - Destination contains a duplicate of the source data.
--*/
{
NTSTATUS NtStatus;
Destination->Index = Index;
Destination->Rid = Source->Rid;
Destination->Attributes = Source->Attributes;
//
// Set all strings to NULL initially
//
RtlInitUnicodeString(&Destination->Group, NULL);
RtlInitUnicodeString(&Destination->Comment, NULL);
//
// Copy source data into destination
//
NtStatus = SampDuplicateUnicodeString(&Destination->Group,
&Source->Group);
if (NT_SUCCESS(NtStatus)) {
NtStatus = SampDuplicateUnicodeString(&Destination->Comment,
&Source->Comment);
}
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampDuplicateGroupInfo failed, status = 0x%lx\n", NtStatus));
SampFreeGroupInfo(Destination);
}
return(NtStatus);
}
NTSTATUS
SampDuplicateOemUserInfo(
PDOMAIN_DISPLAY_OEM_USER Destination,
PDOMAIN_DISPLAY_USER Source,
ULONG Index
)
/*++
Routine Description:
This routine allocates space in the destination and copies over the
data from the source into it.
Parameters:
Destination - The structure to copy data into
Source - The structure containing the data to copy
Index - This value will be placed in the destination's Index
field.
Return Values:
STATUS_SUCCESS - Destination contains a duplicate of a subset of
the source data.
--*/
{
NTSTATUS NtStatus;
Destination->Index = Index;
//
// Set all strings to NULL initially
//
RtlInitString(&Destination->User, NULL);
//
// Copy source data into destination
//
NtStatus = SampUnicodeToOemString(&Destination->User,
&Source->LogonName);
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampDuplicateOemUser failed, status = 0x%lx\n", NtStatus));
RtlInitString(&Destination->User, NULL);
}
return(NtStatus);
}
NTSTATUS
SampDuplicateOemGroupInfo(
PDOMAIN_DISPLAY_OEM_GROUP Destination,
PDOMAIN_DISPLAY_GROUP Source,
ULONG Index
)
/*++
Routine Description:
This routine allocates space in the destination and copies over the
data from the source into it.
Parameters:
Destination - The structure to copy data into
Source - The structure containing the data to copy
Index - This value will be placed in the destination's Index
field.
Return Values:
STATUS_SUCCESS - Destination contains a duplicate of a subset of
the source data.
--*/
{
NTSTATUS NtStatus;
Destination->Index = Index;
//
// Set all strings to NULL initially
//
RtlInitString(&Destination->Group, NULL);
//
// Copy source data into destination
//
NtStatus = SampUnicodeToOemString(&Destination->Group,
&Source->Group);
//
// Clean up on failure
//
if (!NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE_ERRORS,
("SAM: SampDuplicateOemGroup failed, status = 0x%lx\n", NtStatus));
RtlInitString(&Destination->Group, NULL);
}
return(NtStatus);
}
VOID
SampSwapUserInfo(
PDOMAIN_DISPLAY_USER Info1,
PDOMAIN_DISPLAY_USER Info2
)
/*++
Routine Description:
Swap the field contents of Info1 and Info2.
Parameters:
Info1 & Info2 - The structures whose contents are to be swapped.
Return Values:
None
--*/
{
DOMAIN_DISPLAY_USER
Tmp;
Tmp.LogonName = Info1->LogonName;
Tmp.AdminComment = Info1->AdminComment;
Tmp.FullName = Info1->FullName;
Tmp.AccountControl = Info1->AccountControl;
Info1->LogonName = Info2->LogonName;
Info1->AdminComment = Info2->AdminComment;
Info1->FullName = Info2->FullName;
Info1->AccountControl = Info2->AccountControl;
Info2->LogonName = Tmp.LogonName;
Info2->AdminComment = Tmp.AdminComment;
Info2->FullName = Tmp.FullName;
Info2->AccountControl = Tmp.AccountControl;
return;
}
VOID
SampSwapMachineInfo(
PDOMAIN_DISPLAY_MACHINE Info1,
PDOMAIN_DISPLAY_MACHINE Info2
)
/*++
Routine Description:
Swap the field contents of Info1 and Info2.
Parameters:
Info1 & Info2 - The structures whose contents are to be swapped.
Return Values:
None
--*/
{
DOMAIN_DISPLAY_MACHINE
Tmp;
Tmp.Machine = Info1->Machine;
Tmp.Comment = Info1->Comment;
Tmp.AccountControl = Info1->AccountControl;
Info1->Machine = Info2->Machine;
Info1->Comment = Info2->Comment;
Info1->AccountControl = Info2->AccountControl;
Info2->Machine = Tmp.Machine;
Info2->Comment = Tmp.Comment;
Info2->AccountControl = Tmp.AccountControl;
return;
}
VOID
SampSwapGroupInfo(
PDOMAIN_DISPLAY_GROUP Info1,
PDOMAIN_DISPLAY_GROUP Info2
)
/*++
Routine Description:
Swap the field contents of Info1 and Info2.
Parameters:
Info1 & Info2 - The structures whose contents are to be swapped.
Return Values:
None
--*/
{
DOMAIN_DISPLAY_GROUP
Tmp;
Tmp.Group = Info1->Group;
Tmp.Comment = Info1->Comment;
Tmp.Attributes = Info1->Attributes;
Info1->Group = Info2->Group;
Info1->Comment = Info2->Comment;
Info1->Attributes = Info2->Attributes;
Info2->Group = Tmp.Group;
Info2->Comment = Tmp.Comment;
Info2->Attributes = Tmp.Attributes;
return;
}
VOID
SampFreeUserInfo(
PDOMAIN_DISPLAY_USER UserInfo
)
/*++
Routine Description:
Frees data associated with a userinfo structure.
Parameters:
UserInfo - User structure to free
Return Values:
None
--*/
{
SampFreeUnicodeString(&UserInfo->LogonName);
SampFreeUnicodeString(&UserInfo->AdminComment);
SampFreeUnicodeString(&UserInfo->FullName);
MIDL_user_free( UserInfo );
return;
}
VOID
SampFreeMachineInfo(
PDOMAIN_DISPLAY_MACHINE MachineInfo
)
/*++
Routine Description:
Frees data associated with a machineinfo structure.
Parameters:
UserInfo - User structure to free
Return Values:
None
--*/
{
SampFreeUnicodeString(&MachineInfo->Machine);
SampFreeUnicodeString(&MachineInfo->Comment);
MIDL_user_free( MachineInfo );
return;
}
VOID
SampFreeGroupInfo(
PDOMAIN_DISPLAY_GROUP GroupInfo
)
/*++
Routine Description:
Frees data associated with a Groupinfo structure.
Parameters:
UserInfo - User structure to free
Return Values:
None
--*/
{
SampFreeUnicodeString(&GroupInfo->Group);
SampFreeUnicodeString(&GroupInfo->Comment);
MIDL_user_free( GroupInfo );
return;
}
VOID
SampFreeOemUserInfo(
PDOMAIN_DISPLAY_OEM_USER UserInfo
)
/*++
Routine Description:
Frees data associated with a UserInfo structure.
Parameters:
UserInfo - User structure to free
Return Values:
None
--*/
{
SampFreeOemString(&UserInfo->User);
MIDL_user_free( UserInfo );
return;
}
VOID
SampFreeOemGroupInfo(
PDOMAIN_DISPLAY_OEM_GROUP GroupInfo
)
/*++
Routine Description:
Frees data associated with a GroupInfo structure.
Parameters:
GroupInfo - Group structure to free
Return Values:
None
--*/
{
SampFreeOemString(&GroupInfo->Group);
MIDL_user_free( GroupInfo );
return;
}
ULONG
SampBytesRequiredUserNode (
PDOMAIN_DISPLAY_USER Node
)
/*++
Routine Description:
This routines returns the total number of bytes required to store all
the elements of the the specified node.
Parameters:
Node - The node whose size we will return.
Return Values:
Bytes required by node
--*/
{
return( sizeof(*Node) +
Node->LogonName.Length +
Node->AdminComment.Length +
Node->FullName.Length
);
}
ULONG
SampBytesRequiredMachineNode (
PDOMAIN_DISPLAY_MACHINE Node
)
/*++
Routine Description:
This routines returns the total number of bytes required to store all
the elements of the the specified node.
Parameters:
Node - The node whose size we will return.
Return Values:
Bytes required by node
--*/
{
return( sizeof(*Node) +
Node->Machine.Length +
Node->Comment.Length
);
}
ULONG
SampBytesRequiredGroupNode (
PDOMAIN_DISPLAY_GROUP Node
)
/*++
Routine Description:
This routines returns the total number of bytes required to store all
the elements of the the specified node.
Parameters:
Node - The node whose size we will return.
Return Values:
Bytes required by node
--*/
{
return( sizeof(*Node) + Node->Group.Length + Node->Comment.Length );
}
ULONG
SampBytesRequiredOemUserNode (
PDOMAIN_DISPLAY_OEM_USER Node
)
/*++
Routine Description:
This routines returns the total number of bytes required to store all
the elements of the the specified node.
Parameters:
Node - The node whose size we will return.
Return Values:
Bytes required by node
--*/
{
return( sizeof(*Node) + Node->User.Length );
}
ULONG
SampBytesRequiredOemGroupNode (
PDOMAIN_DISPLAY_OEM_GROUP Node
)
/*++
Routine Description:
This routines returns the total number of bytes required to store all
the elements of the the specified node.
Parameters:
Node - The node whose size we will return.
Return Values:
Bytes required by node
--*/
{
return( sizeof(*Node) + Node->Group.Length );
}
PVOID
SampGenericTable2Allocate (
CLONG BufferSize
)
/*++
Routine Description:
This routine is used by the generic table2 package to allocate
memory.
Parameters:
BufferSize - the number of bytes needed.
Return Values:
Pointer to the allocated memory
--*/
{
PVOID
Buffer;
Buffer = MIDL_user_allocate(BufferSize);
#if DBG
if (Buffer == NULL) {
SampDiagPrint( DISPLAY_CACHE_ERRORS,
("SAM: GenTab alloc of %d bytes failed.\n",
BufferSize) );
}
#endif //DBG
return(Buffer);
}
VOID
SampGenericTable2Free (
PVOID Buffer
)
/*++
Routine Description:
This routines frees memory previously allocated using
SampGenericTable2Allocate().
Parameters:
Node - the memory to free.
Return Values:
None.
--*/
{
//
// Free up the base structure
//
MIDL_user_free(Buffer);
return;
}
RTL_GENERIC_COMPARE_RESULTS
SampCompareUserNodeByName (
PVOID Node1,
PVOID Node2
)
/*++
Routine Description:
This routines compares account name fields of two user nodes.
Parameters:
Node1, Node2, the nodes to compare
Return Values:
GenericLessThan - Node1 < Node2
GenericGreaterThan - Node1 > Node2
GenericEqual - Node1 == Node2
--*/
{
PUNICODE_STRING
NodeName1,
NodeName2;
LONG
NameComparison;
NodeName1 = &((PDOMAIN_DISPLAY_USER)Node1)->LogonName;
NodeName2 = &((PDOMAIN_DISPLAY_USER)Node2)->LogonName;
//
// Do a case-insensitive comparison of the node names
//
NameComparison = SampCompareDisplayStrings(NodeName1, NodeName2, TRUE);
if (NameComparison > 0) {
return(GenericGreaterThan);
}
if (NameComparison < 0) {
return(GenericLessThan);
}
return(GenericEqual);
}
RTL_GENERIC_COMPARE_RESULTS
SampCompareMachineNodeByName (
PVOID Node1,
PVOID Node2
)
/*++
Routine Description:
This routines compares account name fields of two machine nodes.
Parameters:
Node1, Node2, the nodes to compare
Return Values:
GenericLessThan - Node1 < Node2
GenericGreaterThan - Node1 > Node2
GenericEqual - Node1 == Node2
--*/
{
PUNICODE_STRING
NodeName1,
NodeName2;
LONG
NameComparison;
NodeName1 = &((PDOMAIN_DISPLAY_MACHINE)Node1)->Machine;
NodeName2 = &((PDOMAIN_DISPLAY_MACHINE)Node2)->Machine;
//
// Do a case-insensitive comparison of the node names
//
NameComparison = SampCompareDisplayStrings(NodeName1, NodeName2, TRUE);
if (NameComparison > 0) {
return(GenericGreaterThan);
}
if (NameComparison < 0) {
return(GenericLessThan);
}
return(GenericEqual);
}
RTL_GENERIC_COMPARE_RESULTS
SampCompareGroupNodeByName (
PVOID Node1,
PVOID Node2
)
/*++
Routine Description:
This routines compares account name fields of two group nodes.
Parameters:
Node1, Node2, the nodes to compare
Return Values:
GenericLessThan - Node1 < Node2
GenericGreaterThan - Node1 > Node2
GenericEqual - Node1 == Node2
--*/
{
PUNICODE_STRING
NodeName1,
NodeName2;
LONG
NameComparison;
NodeName1 = &((PDOMAIN_DISPLAY_GROUP)Node1)->Group;
NodeName2 = &((PDOMAIN_DISPLAY_GROUP)Node2)->Group;
//
// Do a case-insensitive comparison of the node names
//
NameComparison = SampCompareDisplayStrings(NodeName1, NodeName2, TRUE);
if (NameComparison > 0) {
return(GenericGreaterThan);
}
if (NameComparison < 0) {
return(GenericLessThan);
}
return(GenericEqual);
}
RTL_GENERIC_COMPARE_RESULTS
SampCompareNodeByRid (
PVOID Node1,
PVOID Node2
)
/*++
Routine Description:
This routines compares the RID of two nodes.
Parameters:
Node1, Node2, the nodes to compare
Return Values:
GenericLessThan - Node1 < Node2
GenericGreaterThan - Node1 > Node2
GenericEqual - Node1 == Node2
--*/
{
PDOMAIN_DISPLAY_USER
N1,
N2;
//
// This routine assumes that all nodes have RIDs in the same
// place, regardless of node type.
//
ASSERT(FIELD_OFFSET(DOMAIN_DISPLAY_USER, Rid) ==
FIELD_OFFSET(DOMAIN_DISPLAY_MACHINE, Rid));
ASSERT(FIELD_OFFSET(DOMAIN_DISPLAY_USER, Rid) ==
FIELD_OFFSET(DOMAIN_DISPLAY_GROUP, Rid));
N1 = Node1;
N2 = Node2;
if (N1->Rid < N2->Rid) {
return(GenericLessThan);
}
if (N1->Rid > N2->Rid) {
return(GenericGreaterThan);
}
return(GenericEqual);
}
LONG
SampCompareDisplayStrings(
IN PUNICODE_STRING String1,
IN PUNICODE_STRING String2,
IN BOOLEAN IgnoreCase
)
/*++
Routine Description:
This routine is a replacement for RtlCompareUnicodeString().
The difference between RtlCompareUnicodeString() and this routine
is that this routine takes into account various customer selected
sort criteria (like, how is "A-MarilF" sorted in comparison to
"Alfred"). This routine uses CompareStringW() for its comparison
function.
Parameters:
String1 - Points to a unicode string to compare.
String2 - Points to a unicode string to compare.
IgnoreCase - indicates whether the comparison is to be case
sensitive (FALSE) or case insensitive (TRUE).
Return Values:
-1 - String1 is lexically less than string 2. That is, String1
preceeds String2 in an ordered list.
0 - String1 and String2 are lexically equivalent.
-1 - String1 is lexically greater than string 2. That is, String1
follows String2 in an ordered list.
--*/
{
INT
CompareResult;
DWORD
Options = 0;
if (IgnoreCase) {
Options = NORM_IGNORECASE;
}
CompareResult = CompareStringW( SampSystemDefaultLCID,
Options,
String1->Buffer,
(String1->Length / sizeof(WCHAR)),
String2->Buffer,
(String2->Length / sizeof(WCHAR))
);
//
// Note that CompareStringW() returns values 1, 2, and 3 for
// string1 less than, equal, or greater than string2 (respectively)
// So, to obtain the RtlCompareUnicodeString() return values of
// -1, 0, and 1 for the same meaning, we simply have to subtract 2.
//
CompareResult -= 2;
//
// CompareStringW has the property that alternate spellings may
// produce strings that compare identically while the rest of SAM
// treats the strings as different. To get around this, if the
// strings are the same we call RtlCompareUnicodeString to make
// sure the strings really are the same.
//
if (CompareResult == 0) {
CompareResult = RtlCompareUnicodeString(
String1,
String2,
IgnoreCase
);
}
return(CompareResult);
}
#if SAMP_DIAGNOSTICS
///////////////////////////////////////////////////////////////////////////////
// //
// Internal diagnostics //
// //
///////////////////////////////////////////////////////////////////////////////
#define SAMP_DISPLAY_DIAG_ENUM_RIDS (0x00000001)
VOID
SampDisplayDiagnosticSuccess(
IN NTSTATUS s,
IN BOOLEAN Eol
)
/*++
Routine Description:
This routine prints "Success" or "Failure" depending upon the
the passed in status value.
If failure, it also prints the status code.
Parameters:
s - the status value.
Eol - if TRUE, causes an end of line to also be printed.
Return Values:
--*/
{
if (NT_SUCCESS(s)) {
SampDiagPrint(DISPLAY_CACHE, ("Success"));
} else {
SampDiagPrint(DISPLAY_CACHE, ("Failure - Status: 0x%lx", s));
}
if (Eol) {
SampDiagPrint(DISPLAY_CACHE, ("\n"));
}
return;
}
VOID
SampDisplayDiagnostic(
VOID
)
/*++
Routine Description:
This routine provides internal diagnostics and test capabilities.
This routine is called whenever an account called SAMP_DIAG is
modified such that the display cache requires updating.
This routine breakpoints, allowing diagnostic parameters to be set.
Parameters:
None.
Return Values:
--*/
{
ULONG
DiagnosticRunCount = 0,
DiagnosticsToRun = 0;
SampDiagPrint(DISPLAY_CACHE,
("SAM: SampDisplayDiagnostic() called.\n"
" Breakpointing to allow diagnostic parameters to be set.\n"
" Diagnostic Flag Word: 0x%lx\n"
" Diagnostic values: \n"
" SamIEnumerateAccountRids: 0x%lx\n"
"\n",
&DiagnosticsToRun,
SAMP_DISPLAY_DIAG_ENUM_RIDS
) );
DbgBreakPoint();
if ((DiagnosticsToRun & SAMP_DISPLAY_DIAG_ENUM_RIDS) != 0) {
SampDisplayDiagEnumRids();
DiagnosticRunCount++;
}
SampDiagPrint(DISPLAY_CACHE,
("SAM: SampDisplayDiagnostic() - %d diagnostics run.\n",
DiagnosticRunCount) );
return;
}
VOID
SampDisplayDiagEnumRids(
VOID
)
/*++
Routine Description:
This routine tests the RID table enumeration api
(SamIEnumerateAccountRids()).
Parameters:
None.
Return Values:
--*/
{
NTSTATUS
NtStatus;
ULONG
i,
ReturnCount,
LastRid;
PULONG
AccountRids;
SAMPR_HANDLE
Server,
Domain;
SampDiagPrint(DISPLAY_CACHE,
("SAM: Testing SamIEnumerateAccountRids...\n"));
NtStatus = SamIConnect( L"", //ServerName
&Server, //ServerHandle
0, //DesiredAccess
TRUE //TrustedClient
);
ASSERT(NT_SUCCESS(NtStatus));
NtStatus = SamrOpenDomain( Server,
0, //DesiredAccess
SampDefinedDomains[1].Sid, //DomainId
&Domain
);
ASSERT(NT_SUCCESS(NtStatus));
///////////////////////////////////////////////////////////////////
// //
// Enumerate both USERs and GLOBAL GROUPs //
// //
///////////////////////////////////////////////////////////////////
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating first three users and global groups...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_USER_ACCOUNT | SAM_GLOBAL_GROUP_ACCOUNT,
0, //StartingRid
3*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
for (i=0; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx\n", AccountRids[i]));
}
LastRid = AccountRids[ReturnCount-1];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
//
// Now try to continue for another 100 accounts
//
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating next 100 users and global groups...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_USER_ACCOUNT | SAM_GLOBAL_GROUP_ACCOUNT,
LastRid, //StartingRid
100*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
for (i=0; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx\n", AccountRids[i]));
}
LastRid = AccountRids[ReturnCount-1];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
//
// Now try to continue for another 4000 accounts
//
if (NtStatus == STATUS_MORE_ENTRIES) {
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating next 4000 users and global groups...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_USER_ACCOUNT | SAM_GLOBAL_GROUP_ACCOUNT,
LastRid, //StartingRid
400*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
i=0;
if (ReturnCount > 8) {
for (i=0; i<ReturnCount-8; i=i+8) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
AccountRids[i+0], AccountRids[i+1],
AccountRids[i+2], AccountRids[i+3],
AccountRids[i+4], AccountRids[i+5],
AccountRids[i+6], AccountRids[i+7] ));
}
}
for (i=i; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx ", AccountRids[i]));
}
SampDiagPrint(DISPLAY_CACHE, ("\n"));
LastRid = AccountRids[i];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
}
///////////////////////////////////////////////////////////////////
// //
// Now try just USER accounts //
// //
///////////////////////////////////////////////////////////////////
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating first three users ...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_USER_ACCOUNT,
0, //StartingRid
3*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
for (i=0; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx\n", AccountRids[i]));
}
LastRid = AccountRids[ReturnCount-1];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
//
// Now try to continue for another 100 accounts
//
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating next 100 users...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_USER_ACCOUNT,
LastRid, //StartingRid
100*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
for (i=0; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx\n", AccountRids[i]));
}
LastRid = AccountRids[ReturnCount-1];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
//
// Now try to continue for another 4000 accounts
//
if (NtStatus == STATUS_MORE_ENTRIES) {
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating next 4000 users...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_USER_ACCOUNT,
LastRid, //StartingRid
400*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
i=0;
if (ReturnCount > 8) {
for (i=0; i<ReturnCount-8; i=i+8) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
AccountRids[i+0], AccountRids[i+1],
AccountRids[i+2], AccountRids[i+3],
AccountRids[i+4], AccountRids[i+5],
AccountRids[i+6], AccountRids[i+7] ));
}
}
for (i=i; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx ", AccountRids[i]));
}
SampDiagPrint(DISPLAY_CACHE, ("\n"));
LastRid = AccountRids[i];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
}
///////////////////////////////////////////////////////////////////
// //
// Now just try GLOBAL GROUPs //
// //
///////////////////////////////////////////////////////////////////
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating first three global groups...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_GLOBAL_GROUP_ACCOUNT,
0, //StartingRid
3*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
for (i=0; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx\n", AccountRids[i]));
}
LastRid = AccountRids[ReturnCount-1];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
//
// Now try to continue for another 100 accounts
//
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating next 100 global groups...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_GLOBAL_GROUP_ACCOUNT,
LastRid, //StartingRid
100*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
for (i=0; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx\n", AccountRids[i]));
}
LastRid = AccountRids[ReturnCount-1];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
//
// Now try to continue for another 4000 accounts
//
if (NtStatus == STATUS_MORE_ENTRIES) {
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating next 4000 global groups...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_GLOBAL_GROUP_ACCOUNT,
LastRid, //StartingRid
4000*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
ASSERT(AccountRids != NULL);
i=0;
if (ReturnCount > 8) {
for (i=0; i<ReturnCount-8; i=i+8) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
AccountRids[i+0], AccountRids[i+1],
AccountRids[i+2], AccountRids[i+3],
AccountRids[i+4], AccountRids[i+5],
AccountRids[i+6], AccountRids[i+7] ));
}
}
for (i=i; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx ", AccountRids[i]));
}
SampDiagPrint(DISPLAY_CACHE, ("\n"));
LastRid = AccountRids[i];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
}
//
// Now try to continue an enumeration from the very last RID.
// At one point in time, this use to restart the enumeration
// (which was not correct behaviour). It should indicate that
// there are no more entries.
//
SampDiagPrint(DISPLAY_CACHE,
(" Enumerating next 5 global groups.."
" (should be none to enumerate) ...") );
NtStatus = SamIEnumerateAccountRids( Domain,
SAM_GLOBAL_GROUP_ACCOUNT,
LastRid, //StartingRid
5*sizeof(ULONG), //PreferedMaximumLength
&ReturnCount,
&AccountRids
);
SampDisplayDiagnosticSuccess( NtStatus, TRUE );
if (NT_SUCCESS(NtStatus)) {
SampDiagPrint(DISPLAY_CACHE,
(" %d entries returned.\n", ReturnCount));
if (ReturnCount > 0) {
SampDiagPrint(DISPLAY_CACHE,
(" ERROR - there should be no RIDs returned ! !\n"));
ASSERT(AccountRids != NULL);
i=0;
if (ReturnCount > 8) {
for (i=0; i<ReturnCount-8; i=i+8) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
AccountRids[i+0], AccountRids[i+1],
AccountRids[i+2], AccountRids[i+3],
AccountRids[i+4], AccountRids[i+5],
AccountRids[i+6], AccountRids[i+7] ));
}
}
for (i=i; i<ReturnCount; i++) {
SampDiagPrint(DISPLAY_CACHE,
(" 0x%lx ", AccountRids[i]));
}
SampDiagPrint(DISPLAY_CACHE, ("\n"));
LastRid = AccountRids[i];
MIDL_user_free(AccountRids);
} else {
ASSERT(AccountRids == NULL);
}
}
///////////////////////////////////////////////////////////////////
// //
// Hmmm, can't close handles because it will conflict //
// with the rxact state we already have going. Bummer. //
// //
///////////////////////////////////////////////////////////////////
//NtStatus = SamrCloseHandle( &Domain ); ASSERT(NT_SUCCESS(NtStatus));
//NtStatus = SamrCloseHandle( &Server ); ASSERT(NT_SUCCESS(NtStatus));
return;
}
#endif //SAMP_DIAGNOSTICS
Reference in New Issue View Git Blame Copy Permalink