1582 lines
42 KiB
C
1582 lines
42 KiB
C
/*++
|
||
|
||
Copyright (c) 1991 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
groupp.c
|
||
|
||
Abstract:
|
||
|
||
Private functions for supporting NetGroup API
|
||
|
||
Author:
|
||
|
||
Cliff Van Dyke (cliffv) 06-Mar-1991
|
||
|
||
Environment:
|
||
|
||
User mode only.
|
||
Contains NT-specific code.
|
||
Requires ANSI C extensions: slash-slash comments, long external names.
|
||
|
||
Revision History:
|
||
|
||
17-Apr-1991 (cliffv)
|
||
Incorporated review comments.
|
||
|
||
20-Jan-1992 (madana)
|
||
Sundry API changes
|
||
|
||
--*/
|
||
|
||
#include <nt.h>
|
||
#include <ntrtl.h>
|
||
#include <nturtl.h>
|
||
#undef DOMAIN_ALL_ACCESS // defined in both ntsam.h and ntwinapi.h
|
||
#include <ntsam.h>
|
||
#include <ntlsa.h>
|
||
|
||
#define NOMINMAX // Avoid redefinition of min and max in stdlib.h
|
||
#include <windef.h>
|
||
#include <winbase.h>
|
||
#include <lmcons.h>
|
||
|
||
#include <access.h>
|
||
#include <align.h>
|
||
#include <icanon.h>
|
||
#include <lmaccess.h>
|
||
#include <lmerr.h>
|
||
#include <netdebug.h>
|
||
#include <netlib.h>
|
||
#include <netlibnt.h>
|
||
#include <rpcutil.h>
|
||
#include <stddef.h>
|
||
#include <uasp.h>
|
||
#include <stdlib.h>
|
||
#include <accessp.h>
|
||
|
||
|
||
|
||
NET_API_STATUS
|
||
GrouppChangeMember(
|
||
IN LPCWSTR ServerName OPTIONAL,
|
||
IN LPCWSTR GroupName,
|
||
IN LPCWSTR UserName,
|
||
IN BOOL AddMember
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Common routine to add or remove a member from a group
|
||
|
||
Arguments:
|
||
|
||
ServerName - A pointer to a string containing the name of the remote
|
||
server on which the function is to execute. A NULL pointer
|
||
or string specifies the local machine.
|
||
|
||
GroupName - Name of the group to change membership of.
|
||
|
||
UserName - Name of the user to change membership of.
|
||
|
||
AddMember - True to ADD the user to the group.
|
||
|
||
Return Value:
|
||
|
||
Error code for the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
NET_API_STATUS NetStatus;
|
||
NTSTATUS Status;
|
||
SAM_HANDLE SamServerHandle = NULL;
|
||
SAM_HANDLE DomainHandle = NULL;
|
||
SAM_HANDLE GroupHandle = NULL;
|
||
|
||
//
|
||
// Variables for converting names to relative IDs
|
||
//
|
||
|
||
UNICODE_STRING NameString;
|
||
PULONG RelativeId = NULL;
|
||
PSID_NAME_USE NameUse = NULL;
|
||
|
||
//
|
||
// Connect to the SAM server
|
||
//
|
||
|
||
NetStatus = UaspOpenSam( ServerName,
|
||
FALSE, // Don't try null session
|
||
&SamServerHandle );
|
||
|
||
if ( NetStatus != NERR_Success ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppChangeMember: Cannot UaspOpenSam %ld\n", NetStatus ));
|
||
}
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Open the Domain
|
||
//
|
||
|
||
NetStatus = UaspOpenDomain( SamServerHandle,
|
||
DOMAIN_LOOKUP,
|
||
TRUE, // Account Domain
|
||
&DomainHandle,
|
||
NULL); // DomainId
|
||
|
||
if ( NetStatus != NERR_Success ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppChangeMember: UaspOpenDomain returned %ld\n",
|
||
NetStatus ));
|
||
}
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Open the group
|
||
//
|
||
|
||
NetStatus = GrouppOpenGroup( DomainHandle,
|
||
AddMember ?
|
||
GROUP_ADD_MEMBER : GROUP_REMOVE_MEMBER,
|
||
GroupName,
|
||
&GroupHandle,
|
||
NULL ); // Relative Id
|
||
|
||
if ( NetStatus != NERR_Success ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppChangeMember: GrouppOpenGroup returned %ld\n",
|
||
NetStatus ));
|
||
}
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Convert User name to relative ID.
|
||
//
|
||
|
||
RtlInitUnicodeString( &NameString, UserName );
|
||
Status = SamLookupNamesInDomain( DomainHandle,
|
||
1,
|
||
&NameString,
|
||
&RelativeId,
|
||
&NameUse );
|
||
|
||
if ( !NT_SUCCESS(Status) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppChangeMember: SamLookupNamesInDomain returned %lX\n",
|
||
Status ));
|
||
}
|
||
if ( Status == STATUS_NONE_MAPPED ) {
|
||
NetStatus = NERR_UserNotFound;
|
||
} else {
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
}
|
||
goto Cleanup;
|
||
}
|
||
|
||
if ( *NameUse != SidTypeUser ) {
|
||
NetStatus = NERR_UserNotFound;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Add the user as a member of the group.
|
||
//
|
||
// SE_GROUP_MANDATORY might be conflict with the attributes of the group, so
|
||
// try that attribute both ways.
|
||
//
|
||
|
||
if ( AddMember ) {
|
||
Status = SamAddMemberToGroup(
|
||
GroupHandle,
|
||
*RelativeId,
|
||
SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT |
|
||
SE_GROUP_ENABLED );
|
||
|
||
if ( Status == STATUS_INVALID_GROUP_ATTRIBUTES ) {
|
||
Status = SamAddMemberToGroup( GroupHandle,
|
||
*RelativeId,
|
||
SE_GROUP_ENABLED_BY_DEFAULT |
|
||
SE_GROUP_ENABLED );
|
||
}
|
||
|
||
//
|
||
// Delete the user as a member of the group
|
||
//
|
||
|
||
} else {
|
||
Status = SamRemoveMemberFromGroup( GroupHandle,
|
||
*RelativeId);
|
||
}
|
||
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppChangeMember: SamAdd(orRemove)MemberFromGroup returned %lX\n",
|
||
Status ));
|
||
}
|
||
|
||
if ( !NT_SUCCESS(Status) ) {
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
NetStatus = NERR_Success;
|
||
|
||
//
|
||
// Clean up.
|
||
//
|
||
|
||
Cleanup:
|
||
if ( RelativeId != NULL ) {
|
||
Status = SamFreeMemory( RelativeId );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if ( NameUse != NULL ) {
|
||
Status = SamFreeMemory( NameUse );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if ( GroupHandle != NULL ) {
|
||
(VOID) SamCloseHandle( GroupHandle );
|
||
}
|
||
|
||
UaspCloseDomain( DomainHandle );
|
||
|
||
if ( SamServerHandle != NULL ) {
|
||
(VOID) SamCloseHandle( SamServerHandle );
|
||
}
|
||
return NetStatus;
|
||
|
||
} // GrouppChangeMember
|
||
|
||
|
||
NET_API_STATUS
|
||
GrouppGetInfo(
|
||
IN SAM_HANDLE DomainHandle,
|
||
IN ULONG RelativeId,
|
||
IN DWORD Level,
|
||
OUT PVOID *Buffer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Internal routine to get group information
|
||
|
||
Arguments:
|
||
|
||
DomainHandle - Supplies the Handle of the domain the group is in.
|
||
|
||
RelativeId - Supplies the relative ID of the group to open.
|
||
|
||
Level - Level of information required. 0, 1 and 2 are valid.
|
||
|
||
Buffer - Returns a pointer to the return information structure.
|
||
Caller must deallocate buffer using NetApiBufferFree.
|
||
|
||
Return Value:
|
||
|
||
Error code for the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
NET_API_STATUS NetStatus;
|
||
NTSTATUS Status;
|
||
SAM_HANDLE GroupHandle = NULL;
|
||
GROUP_GENERAL_INFORMATION *GroupGeneral = NULL;
|
||
PVOID lastVarData;
|
||
DWORD BufferSize;
|
||
DWORD FixedSize;
|
||
PSID GroupSid = NULL;
|
||
ULONG RidToReturn = RelativeId;
|
||
|
||
PGROUP_INFO_0 grpi0;
|
||
|
||
//
|
||
// Validate the level
|
||
//
|
||
if ( Level == 2 ) {
|
||
|
||
ULONG Mode;
|
||
Status = SamGetCompatibilityMode(DomainHandle, &Mode);
|
||
if (!NT_SUCCESS(Status)) {
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
switch (Mode) {
|
||
case SAM_SID_COMPATIBILITY_STRICT:
|
||
NetStatus = ERROR_NOT_SUPPORTED;
|
||
goto Cleanup;
|
||
case SAM_SID_COMPATIBILITY_LAX:
|
||
RidToReturn = 0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Open the group
|
||
//
|
||
|
||
Status = SamOpenGroup( DomainHandle,
|
||
GROUP_READ_INFORMATION,
|
||
RelativeId,
|
||
&GroupHandle);
|
||
|
||
if ( !NT_SUCCESS(Status) ) {
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Get the information about the group.
|
||
//
|
||
|
||
Status = SamQueryInformationGroup( GroupHandle,
|
||
GroupReplicationInformation,
|
||
(PVOID *)&GroupGeneral);
|
||
|
||
if ( ! NT_SUCCESS( Status ) ) {
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Obtain the group's sid
|
||
//
|
||
if ( Level == 3 ) {
|
||
|
||
NetStatus = NetpSamRidToSid(DomainHandle,
|
||
RelativeId,
|
||
&GroupSid);
|
||
|
||
if ( NetStatus != NERR_Success ) {
|
||
goto Cleanup;
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// Figure out how big the return buffer needs to be
|
||
//
|
||
|
||
switch ( Level ) {
|
||
case 0:
|
||
FixedSize = sizeof( GROUP_INFO_0 );
|
||
BufferSize = FixedSize +
|
||
GroupGeneral->Name.Length + sizeof(WCHAR);
|
||
break;
|
||
|
||
case 1:
|
||
FixedSize = sizeof( GROUP_INFO_1 );
|
||
BufferSize = FixedSize +
|
||
GroupGeneral->Name.Length + sizeof(WCHAR) +
|
||
GroupGeneral->AdminComment.Length + sizeof(WCHAR);
|
||
break;
|
||
|
||
case 2:
|
||
FixedSize = sizeof( GROUP_INFO_2 );
|
||
BufferSize = FixedSize +
|
||
GroupGeneral->Name.Length + sizeof(WCHAR) +
|
||
GroupGeneral->AdminComment.Length + sizeof(WCHAR);
|
||
break;
|
||
|
||
case 3:
|
||
FixedSize = sizeof( GROUP_INFO_3 );
|
||
BufferSize = FixedSize +
|
||
GroupGeneral->Name.Length + sizeof(WCHAR) +
|
||
GroupGeneral->AdminComment.Length + sizeof(WCHAR) +
|
||
RtlLengthSid(GroupSid);
|
||
|
||
break;
|
||
|
||
default:
|
||
NetStatus = ERROR_INVALID_LEVEL;
|
||
goto Cleanup;
|
||
|
||
}
|
||
|
||
//
|
||
// Allocate the return buffer.
|
||
//
|
||
BufferSize = ROUND_UP_COUNT( BufferSize, ALIGN_DWORD );
|
||
|
||
*Buffer = MIDL_user_allocate( BufferSize );
|
||
|
||
if (*Buffer == NULL ) {
|
||
NetStatus = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
lastVarData = (PBYTE) ((LPBYTE)(*Buffer)) + BufferSize;
|
||
|
||
|
||
//
|
||
// Fill the name into the return buffer.
|
||
//
|
||
|
||
NetpAssert( offsetof( GROUP_INFO_0, grpi0_name ) ==
|
||
offsetof( GROUP_INFO_1, grpi1_name ) );
|
||
|
||
NetpAssert( offsetof( GROUP_INFO_1, grpi1_name ) ==
|
||
offsetof( GROUP_INFO_2, grpi2_name ) );
|
||
|
||
NetpAssert( offsetof( GROUP_INFO_2, grpi2_name ) ==
|
||
offsetof( GROUP_INFO_3, grpi3_name ) );
|
||
|
||
NetpAssert( offsetof( GROUP_INFO_1, grpi1_comment ) ==
|
||
offsetof( GROUP_INFO_2, grpi2_comment ) );
|
||
|
||
NetpAssert( offsetof( GROUP_INFO_2, grpi2_comment ) ==
|
||
offsetof( GROUP_INFO_3, grpi3_comment ) );
|
||
|
||
grpi0 = ((PGROUP_INFO_0)*Buffer);
|
||
|
||
|
||
//
|
||
// Fill in the return buffer.
|
||
//
|
||
|
||
switch ( Level ) {
|
||
case 3:
|
||
{
|
||
PGROUP_INFO_3 grpi3 = ((PGROUP_INFO_3)grpi0);
|
||
|
||
NetpAssert( NULL != GroupSid );
|
||
|
||
if ( !NetpCopyDataToBuffer(
|
||
(LPBYTE) GroupSid,
|
||
RtlLengthSid(GroupSid),
|
||
((LPBYTE)(*Buffer)) + FixedSize,
|
||
(PBYTE*) &lastVarData,
|
||
(LPBYTE *)&grpi3->grpi3_group_sid,
|
||
ALIGN_DWORD ) ) {
|
||
|
||
NetStatus = NERR_InternalError;
|
||
goto Cleanup;
|
||
}
|
||
|
||
((PGROUP_INFO_3)grpi3)->grpi3_attributes = GroupGeneral->Attributes;
|
||
|
||
//
|
||
// Fall through to the next level
|
||
//
|
||
|
||
}
|
||
|
||
case 2:
|
||
|
||
//
|
||
// copy info level 2 only fields
|
||
//
|
||
if ( Level == 2 ) {
|
||
|
||
((PGROUP_INFO_2)grpi0)->grpi2_group_id = RidToReturn;
|
||
|
||
((PGROUP_INFO_2)grpi0)->grpi2_attributes = GroupGeneral->Attributes;
|
||
}
|
||
|
||
|
||
|
||
/* FALL THROUGH FOR OTHER FIELDS */
|
||
|
||
case 1:
|
||
|
||
//
|
||
// copy fields common to info level 1 and 2.
|
||
//
|
||
|
||
|
||
if ( !NetpCopyStringToBuffer(
|
||
GroupGeneral->AdminComment.Buffer,
|
||
GroupGeneral->AdminComment.Length/sizeof(WCHAR),
|
||
((LPBYTE)(*Buffer)) + FixedSize,
|
||
(LPWSTR*)&lastVarData,
|
||
&((PGROUP_INFO_1)grpi0)->grpi1_comment ) ) {
|
||
|
||
NetStatus = NERR_InternalError;
|
||
goto Cleanup;
|
||
}
|
||
|
||
|
||
/* FALL THROUGH FOR NAME FIELD */
|
||
|
||
case 0:
|
||
|
||
//
|
||
// copy common field (name field) in the buffer.
|
||
//
|
||
|
||
if ( !NetpCopyStringToBuffer(
|
||
GroupGeneral->Name.Buffer,
|
||
GroupGeneral->Name.Length/sizeof(WCHAR),
|
||
((LPBYTE)(*Buffer)) + FixedSize,
|
||
(LPWSTR*)&lastVarData,
|
||
&grpi0->grpi0_name ) ) {
|
||
|
||
NetStatus = NERR_InternalError;
|
||
goto Cleanup;
|
||
}
|
||
|
||
|
||
break;
|
||
|
||
default:
|
||
NetStatus = ERROR_INVALID_LEVEL;
|
||
goto Cleanup;
|
||
|
||
}
|
||
|
||
NetStatus = NERR_Success;
|
||
|
||
//
|
||
// Cleanup and return.
|
||
//
|
||
|
||
Cleanup:
|
||
if ( GroupGeneral ) {
|
||
Status = SamFreeMemory( GroupGeneral );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if ( GroupHandle ) {
|
||
(VOID) SamCloseHandle( GroupHandle );
|
||
}
|
||
|
||
if ( GroupSid ) {
|
||
NetpMemoryFree( GroupSid );
|
||
}
|
||
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppGetInfo: returns %ld\n", NetStatus ));
|
||
}
|
||
return NetStatus;
|
||
|
||
} // GrouppGetInfo
|
||
|
||
|
||
NET_API_STATUS
|
||
GrouppOpenGroup(
|
||
IN SAM_HANDLE DomainHandle,
|
||
IN ACCESS_MASK DesiredAccess,
|
||
IN LPCWSTR GroupName,
|
||
OUT PSAM_HANDLE GroupHandle OPTIONAL,
|
||
OUT PULONG RelativeId OPTIONAL
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Open a Sam Group by Name
|
||
|
||
Arguments:
|
||
|
||
DomainHandle - Supplies the Domain Handle.
|
||
|
||
DesiredAccess - Supplies access mask indicating desired access to group.
|
||
|
||
GroupName - Group name of the group.
|
||
|
||
GroupHandle - Returns a handle to the group. If NULL, group is not
|
||
actually opened (merely the relative ID is returned).
|
||
|
||
RelativeId - Returns the relative ID of the group. If NULL the relative
|
||
Id is not returned.
|
||
|
||
Return Value:
|
||
|
||
Error code for the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS Status;
|
||
NET_API_STATUS NetStatus;
|
||
|
||
//
|
||
// Variables for converting names to relative IDs
|
||
//
|
||
|
||
UNICODE_STRING NameString;
|
||
PSID_NAME_USE NameUse;
|
||
PULONG LocalRelativeId;
|
||
|
||
RtlInitUnicodeString( &NameString, GroupName );
|
||
|
||
|
||
//
|
||
// Convert group name to relative ID.
|
||
//
|
||
|
||
Status = SamLookupNamesInDomain( DomainHandle,
|
||
1,
|
||
&NameString,
|
||
&LocalRelativeId,
|
||
&NameUse );
|
||
|
||
if ( !NT_SUCCESS(Status) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppOpenGroup: %wZ: SamLookupNamesInDomain %lX\n",
|
||
&NameString,
|
||
Status ));
|
||
}
|
||
return NetpNtStatusToApiStatus( Status );
|
||
}
|
||
|
||
if ( *NameUse != SidTypeGroup ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppOpenGroup: %wZ: Name is not a group %ld\n",
|
||
&NameString,
|
||
*NameUse ));
|
||
}
|
||
NetStatus = NERR_GroupNotFound;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Open the group
|
||
//
|
||
|
||
if ( GroupHandle != NULL ) {
|
||
Status = SamOpenGroup( DomainHandle,
|
||
DesiredAccess,
|
||
*LocalRelativeId,
|
||
GroupHandle);
|
||
|
||
if ( !NT_SUCCESS(Status) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppOpenGroup: %wZ: SamOpenGroup %lX\n",
|
||
&NameString,
|
||
Status ));
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Return the relative Id if it's wanted.
|
||
//
|
||
|
||
if ( RelativeId != NULL ) {
|
||
*RelativeId = *LocalRelativeId;
|
||
}
|
||
|
||
NetStatus = NERR_Success;
|
||
|
||
|
||
//
|
||
// Cleanup
|
||
//
|
||
|
||
Cleanup:
|
||
if ( LocalRelativeId != NULL ) {
|
||
Status = SamFreeMemory( LocalRelativeId );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if ( NameUse != NULL ) {
|
||
Status = SamFreeMemory( NameUse );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
return NetStatus;
|
||
|
||
|
||
} // GrouppOpenGroup
|
||
|
||
|
||
VOID
|
||
GrouppRelocationRoutine(
|
||
IN DWORD Level,
|
||
IN OUT PBUFFER_DESCRIPTOR BufferDescriptor,
|
||
IN PTRDIFF_T Offset
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Routine to relocate the pointers from the fixed portion of a NetGroupEnum
|
||
enumeration
|
||
buffer to the string portion of an enumeration buffer. It is called
|
||
as a callback routine from NetpAllocateEnumBuffer when it re-allocates
|
||
such a buffer. NetpAllocateEnumBuffer copied the fixed portion and
|
||
string portion into the new buffer before calling this routine.
|
||
|
||
Arguments:
|
||
|
||
Level - Level of information in the buffer.
|
||
|
||
BufferDescriptor - Description of the new buffer.
|
||
|
||
Offset - Offset to add to each pointer in the fixed portion.
|
||
|
||
Return Value:
|
||
|
||
Returns the error code for the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
DWORD EntryCount;
|
||
DWORD EntryNumber;
|
||
DWORD FixedSize;
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppRelocationRoutine: entering\n" ));
|
||
}
|
||
|
||
//
|
||
// Compute the number of fixed size entries
|
||
//
|
||
|
||
switch (Level) {
|
||
case 0:
|
||
FixedSize = sizeof(GROUP_INFO_0);
|
||
break;
|
||
|
||
case 1:
|
||
FixedSize = sizeof(GROUP_INFO_1);
|
||
break;
|
||
|
||
case 2:
|
||
FixedSize = sizeof(GROUP_INFO_2);
|
||
break;
|
||
|
||
default:
|
||
NetpAssert( FALSE );
|
||
return;
|
||
|
||
}
|
||
|
||
EntryCount =
|
||
((DWORD)(BufferDescriptor->FixedDataEnd - BufferDescriptor->Buffer)) /
|
||
FixedSize;
|
||
|
||
//
|
||
// Loop relocating each field in each fixed size structure
|
||
//
|
||
|
||
for ( EntryNumber=0; EntryNumber<EntryCount; EntryNumber++ ) {
|
||
|
||
LPBYTE TheStruct = BufferDescriptor->Buffer + FixedSize * EntryNumber;
|
||
|
||
switch ( Level ) {
|
||
case 2:
|
||
case 1:
|
||
RELOCATE_ONE( ((PGROUP_INFO_1)TheStruct)->grpi1_comment, Offset );
|
||
|
||
//
|
||
// Drop through to case 0
|
||
//
|
||
|
||
case 0:
|
||
RELOCATE_ONE( ((PGROUP_INFO_0)TheStruct)->grpi0_name, Offset );
|
||
break;
|
||
|
||
default:
|
||
return;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return;
|
||
|
||
} // GrouppRelocationRoutine
|
||
|
||
|
||
VOID
|
||
GrouppMemberRelocationRoutine(
|
||
IN DWORD Level,
|
||
IN OUT PBUFFER_DESCRIPTOR BufferDescriptor,
|
||
IN PTRDIFF_T Offset
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Routine to relocate the pointers from the fixed portion of a
|
||
NetGroupGetUsers enumeration
|
||
buffer to the string portion of an enumeration buffer. It is called
|
||
as a callback routine from NetpAllocateEnumBuffer when it re-allocates
|
||
such a buffer. NetpAllocateEnumBuffer copied the fixed portion and
|
||
string portion into the new buffer before calling this routine.
|
||
|
||
Arguments:
|
||
|
||
Level - Level of information in the buffer.
|
||
|
||
BufferDescriptor - Description of the new buffer.
|
||
|
||
Offset - Offset to add to each pointer in the fixed portion.
|
||
|
||
Return Value:
|
||
|
||
Returns the error code for the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
DWORD EntryCount;
|
||
DWORD EntryNumber;
|
||
DWORD FixedSize;
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppMemberRelocationRoutine: entering\n" ));
|
||
}
|
||
|
||
//
|
||
// Compute the number of fixed size entries
|
||
//
|
||
|
||
switch (Level) {
|
||
case 0:
|
||
FixedSize = sizeof(GROUP_USERS_INFO_0);
|
||
break;
|
||
|
||
case 1:
|
||
FixedSize = sizeof(GROUP_USERS_INFO_1);
|
||
break;
|
||
|
||
default:
|
||
NetpAssert( FALSE );
|
||
return;
|
||
|
||
}
|
||
|
||
EntryCount =
|
||
((DWORD)(BufferDescriptor->FixedDataEnd - BufferDescriptor->Buffer)) /
|
||
FixedSize;
|
||
|
||
//
|
||
// Loop relocating each field in each fixed size structure
|
||
//
|
||
|
||
for ( EntryNumber=0; EntryNumber<EntryCount; EntryNumber++ ) {
|
||
|
||
LPBYTE TheStruct = BufferDescriptor->Buffer + FixedSize * EntryNumber;
|
||
|
||
//
|
||
// Both info levels only have one field to relocate
|
||
//
|
||
|
||
RELOCATE_ONE( ((PGROUP_USERS_INFO_0)TheStruct)->grui0_name, Offset );
|
||
|
||
|
||
}
|
||
|
||
return;
|
||
|
||
} // GrouppMemberRelocationRoutine
|
||
|
||
|
||
|
||
NET_API_STATUS
|
||
GrouppSetUsers (
|
||
IN LPCWSTR ServerName OPTIONAL,
|
||
IN LPCWSTR GroupName,
|
||
IN DWORD Level,
|
||
IN LPBYTE Buffer,
|
||
IN DWORD NewMemberCount,
|
||
IN BOOL DeleteGroup
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Set the list of members of a group and optionally delete the group
|
||
when finished.
|
||
|
||
The members specified by "Buffer" are called new members. The current
|
||
members of the group are called old members. Members which are
|
||
on both the old and new list are common members.
|
||
|
||
The SAM API allows only one member to be added or deleted at a time.
|
||
This API allows all of the members of a group to be specified en-masse.
|
||
This API is careful to always leave the group membership in the SAM
|
||
database in a reasonable state. It does by mergeing the list of
|
||
old and new members, then only changing those memberships which absolutely
|
||
need changing.
|
||
|
||
Group membership is restored to its previous state (if possible) if
|
||
an error occurs during changing the group membership.
|
||
|
||
Arguments:
|
||
|
||
ServerName - A pointer to a string containing the name of the remote
|
||
server on which the function is to execute. A NULL pointer
|
||
or string specifies the local machine.
|
||
|
||
GroupName - Name of the group to modify.
|
||
|
||
Level - Level of information provided. Must be 0 or 1.
|
||
|
||
Buffer - A pointer to the buffer containing an array of NewMemberCount
|
||
the group membership information structures.
|
||
|
||
NewMemberCount - Number of entries in Buffer.
|
||
|
||
DeleteGroup - TRUE if the group is to be deleted after changing the
|
||
membership.
|
||
|
||
Return Value:
|
||
|
||
Error code for the operation.
|
||
|
||
--*/
|
||
|
||
{
|
||
NET_API_STATUS NetStatus;
|
||
NTSTATUS Status;
|
||
SAM_HANDLE SamServerHandle = NULL;
|
||
SAM_HANDLE DomainHandle = NULL;
|
||
SAM_HANDLE GroupHandle = NULL;
|
||
ACCESS_MASK DesiredAccess;
|
||
|
||
//
|
||
// Variables for dealing with old or new lists of members
|
||
//
|
||
|
||
PULONG NewRelativeIds = NULL; // Relative Ids of the new members
|
||
PULONG OldRelativeIds = NULL; // Relative Ids of the old members
|
||
PULONG OldAttributes = NULL; // Attributes of the old members
|
||
|
||
PSID_NAME_USE NewNameUse = NULL;// Name usage of the new members
|
||
PSID_NAME_USE OldNameUse = NULL;// Name usage of the old members
|
||
|
||
PUNICODE_STRING NameStrings = NULL; // Names of a list of members
|
||
|
||
ULONG OldMemberCount; // Number of current members in the group
|
||
|
||
ULONG DefaultMemberAttributes; // Default attributes for new members
|
||
|
||
DWORD FixedSize;
|
||
|
||
//
|
||
// Define an internal member list structure.
|
||
//
|
||
// The structure defines a list of new members to be added, members whose
|
||
// attributes merely need to be changed, and members which
|
||
// need to be deleted. The list is maintained in relative ID sorted
|
||
// order.
|
||
//
|
||
|
||
struct _MEMBER_DESCRIPTION {
|
||
struct _MEMBER_DESCRIPTION * Next; // Next entry in linked list;
|
||
|
||
ULONG RelativeId; // Relative ID of this member
|
||
|
||
enum _Action { // Action taken for this member
|
||
AddMember, // Add Member to group
|
||
RemoveMember, // Remove Member from group
|
||
SetAttributesMember, // Change the Members attributes
|
||
IgnoreMember // Ignore this member
|
||
} Action;
|
||
|
||
ULONG NewAttributes; // Attributes to set for the member
|
||
|
||
BOOL Done; // True if this action has been taken
|
||
|
||
ULONG OldAttributes; // Attributes to restore on a recovery
|
||
|
||
} *MemberList = NULL , *CurEntry, **Entry;
|
||
|
||
//
|
||
// Connect to the SAM server
|
||
//
|
||
|
||
NetStatus = UaspOpenSam( ServerName,
|
||
FALSE, // Don't try null session
|
||
&SamServerHandle );
|
||
|
||
if ( NetStatus != NERR_Success ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppSetUsers: Cannot UaspOpenSam %ld\n", NetStatus ));
|
||
}
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Open the Domain
|
||
//
|
||
|
||
NetStatus = UaspOpenDomain( SamServerHandle,
|
||
DOMAIN_LOOKUP,
|
||
TRUE, // Account Domain
|
||
&DomainHandle,
|
||
NULL); // DomainId
|
||
|
||
if ( NetStatus != NERR_Success ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppSetUsers: UaspOpenDomain returns %ld\n",
|
||
NetStatus ));
|
||
}
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Open the group
|
||
//
|
||
DesiredAccess = GROUP_READ_INFORMATION | GROUP_LIST_MEMBERS |
|
||
GROUP_ADD_MEMBER | GROUP_REMOVE_MEMBER;
|
||
if ( DeleteGroup ) {
|
||
NetpAssert( NewMemberCount == 0 );
|
||
DesiredAccess |= DELETE;
|
||
}
|
||
|
||
NetStatus = GrouppOpenGroup( DomainHandle,
|
||
DesiredAccess,
|
||
GroupName,
|
||
&GroupHandle,
|
||
NULL ); // Relative Id
|
||
|
||
if ( NetStatus != NERR_Success ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppSetUsers: GrouppOpenGroup returns %ld\n",
|
||
NetStatus ));
|
||
}
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Validate the level
|
||
//
|
||
|
||
switch (Level) {
|
||
case 0: {
|
||
|
||
//
|
||
// Determine the attributes of the group as a whole. Use that
|
||
// for deciding on the default attributes for new members.
|
||
//
|
||
|
||
PGROUP_ATTRIBUTE_INFORMATION Attributes;
|
||
|
||
Status = SamQueryInformationGroup( GroupHandle,
|
||
GroupAttributeInformation,
|
||
(PVOID*)&Attributes );
|
||
|
||
if ( !NT_SUCCESS(Status) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppSetUsers: SamQueryInformationGroup returns %lX\n",
|
||
Status ));
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
DefaultMemberAttributes =
|
||
(Attributes->Attributes & SE_GROUP_MANDATORY) |
|
||
SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED ;
|
||
|
||
FixedSize = sizeof( GROUP_USERS_INFO_0 );
|
||
|
||
Status = SamFreeMemory( Attributes );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
|
||
break;
|
||
}
|
||
|
||
case 1:
|
||
FixedSize = sizeof( GROUP_USERS_INFO_1 );
|
||
break;
|
||
|
||
default:
|
||
NetStatus = ERROR_INVALID_LEVEL;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Determine the Relative Id and usage of each of the new members.
|
||
//
|
||
|
||
if ( NewMemberCount > 0 ) {
|
||
DWORD NewIndex; // Index to a new member
|
||
PGROUP_USERS_INFO_0 grui0;
|
||
|
||
//
|
||
// Allocate a buffer big enough to contain all the string variables
|
||
// for the new member names.
|
||
//
|
||
|
||
NameStrings = NetpMemoryAllocate( NewMemberCount *
|
||
sizeof(UNICODE_STRING) );
|
||
|
||
if ( NameStrings == NULL ) {
|
||
NetStatus = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Fill in the list of member name strings for each new member.
|
||
//
|
||
|
||
NetpAssert( offsetof( GROUP_USERS_INFO_0, grui0_name ) ==
|
||
offsetof( GROUP_USERS_INFO_1, grui1_name ) );
|
||
|
||
for ( NewIndex=0, grui0 = (PGROUP_USERS_INFO_0)Buffer;
|
||
NewIndex<NewMemberCount;
|
||
NewIndex++,
|
||
grui0 = (PGROUP_USERS_INFO_0)
|
||
((LPBYTE)grui0 + FixedSize) ) {
|
||
|
||
RtlInitUnicodeString(&NameStrings[NewIndex], grui0->grui0_name);
|
||
|
||
}
|
||
|
||
//
|
||
// Convert the member names to relative Ids.
|
||
//
|
||
|
||
Status = SamLookupNamesInDomain( DomainHandle,
|
||
NewMemberCount,
|
||
NameStrings,
|
||
&NewRelativeIds,
|
||
&NewNameUse );
|
||
|
||
if ( !NT_SUCCESS( Status )) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppSetUsers: SamLookupNamesInDomain returns %lX\n",
|
||
Status ));
|
||
}
|
||
if ( Status == STATUS_NONE_MAPPED ) {
|
||
NetStatus = NERR_UserNotFound;
|
||
goto Cleanup;
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Build a member entry for each of the new members.
|
||
// The list is maintained in RelativeId sorted order.
|
||
//
|
||
|
||
for ( NewIndex=0; NewIndex<NewMemberCount; NewIndex++ ) {
|
||
|
||
//
|
||
// Ensure this new member name is an existing user name.
|
||
// Group names are not allowed to be added via this API.
|
||
//
|
||
|
||
if (NewNameUse[NewIndex] != SidTypeUser) {
|
||
NetStatus = NERR_UserNotFound;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// Find the place to put the new entry
|
||
//
|
||
|
||
Entry = &MemberList ;
|
||
while ( *Entry != NULL &&
|
||
(*Entry)->RelativeId < NewRelativeIds[NewIndex] ) {
|
||
|
||
Entry = &( (*Entry)->Next );
|
||
}
|
||
|
||
//
|
||
// If this is not a duplicate entry, allocate a new member structure
|
||
// and fill it in.
|
||
//
|
||
// Just ignore duplicate relative Ids.
|
||
//
|
||
|
||
if ( *Entry == NULL ||
|
||
(*Entry)->RelativeId > NewRelativeIds[NewIndex] ) {
|
||
|
||
CurEntry = NetpMemoryAllocate(
|
||
sizeof(struct _MEMBER_DESCRIPTION));
|
||
|
||
if ( CurEntry == NULL ) {
|
||
NetStatus = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
CurEntry->Next = *Entry;
|
||
CurEntry->RelativeId = NewRelativeIds[NewIndex];
|
||
CurEntry->Action = AddMember;
|
||
CurEntry->Done = FALSE;
|
||
|
||
CurEntry->NewAttributes = ( Level == 1 ) ?
|
||
((PGROUP_USERS_INFO_1)Buffer)[NewIndex].grui1_attributes :
|
||
DefaultMemberAttributes;
|
||
|
||
*Entry = CurEntry;
|
||
}
|
||
}
|
||
|
||
NetpMemoryFree( NameStrings );
|
||
NameStrings = NULL;
|
||
|
||
Status = SamFreeMemory( NewRelativeIds );
|
||
NewRelativeIds = NULL;
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
|
||
Status = SamFreeMemory( NewNameUse );
|
||
NewNameUse = NULL;
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
//
|
||
// Determine the number of old members for this group and the
|
||
// relative ID's of the old members.
|
||
//
|
||
|
||
Status = SamGetMembersInGroup(
|
||
GroupHandle,
|
||
&OldRelativeIds,
|
||
&OldAttributes,
|
||
&OldMemberCount );
|
||
|
||
if ( !NT_SUCCESS( Status ) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppSetUsers: SamGetMembersInGroup returns %lX\n",
|
||
Status ));
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// If there are any old members,
|
||
// Merge them into the list.
|
||
//
|
||
|
||
if ( OldMemberCount > 0 ) {
|
||
ULONG OldIndex; // Index to current entry
|
||
PUNICODE_STRING Names;
|
||
|
||
|
||
//
|
||
// Determine the usage for all the returned relative Ids.
|
||
//
|
||
|
||
Status = SamLookupIdsInDomain(
|
||
DomainHandle,
|
||
OldMemberCount,
|
||
OldRelativeIds,
|
||
&Names,
|
||
&OldNameUse );
|
||
|
||
if ( !NT_SUCCESS( Status ) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppSetUsers: SamLookupIdsInDomain returns %lX\n",
|
||
Status ));
|
||
}
|
||
|
||
if ( Status == STATUS_NONE_MAPPED ) {
|
||
NetStatus = NERR_InternalError ;
|
||
goto Cleanup;
|
||
}
|
||
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
Status = SamFreeMemory( Names ); // Don't need names at all
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
|
||
|
||
//
|
||
// Loop for each current member
|
||
//
|
||
|
||
for ( OldIndex=0; OldIndex<OldMemberCount; OldIndex++ ) {
|
||
|
||
//
|
||
// Ignore old members which aren't a user.
|
||
//
|
||
|
||
if ( OldNameUse[OldIndex] != SidTypeUser ) {
|
||
|
||
//
|
||
// ?? Why? is't it internal error ?
|
||
//
|
||
|
||
continue;
|
||
}
|
||
|
||
//
|
||
// Find the place to put the new entry
|
||
//
|
||
|
||
Entry = &MemberList ;
|
||
while ( *Entry != NULL &&
|
||
(*Entry)->RelativeId < OldRelativeIds[OldIndex] ) {
|
||
|
||
Entry = &( (*Entry)->Next );
|
||
}
|
||
|
||
//
|
||
// If this entry is not already in the list,
|
||
// this is a member which exists now but should be deleted.
|
||
//
|
||
|
||
if( *Entry == NULL || (*Entry)->RelativeId > OldRelativeIds[OldIndex]){
|
||
|
||
CurEntry =
|
||
NetpMemoryAllocate(sizeof(struct _MEMBER_DESCRIPTION));
|
||
if ( CurEntry == NULL ) {
|
||
NetStatus = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
|
||
CurEntry->Next = *Entry;
|
||
CurEntry->RelativeId = OldRelativeIds[OldIndex];
|
||
CurEntry->Action = RemoveMember;
|
||
CurEntry->Done = FALSE;
|
||
CurEntry->OldAttributes = OldAttributes[OldIndex];
|
||
|
||
*Entry = CurEntry;
|
||
|
||
//
|
||
// Handle the case where this member is already in the list
|
||
//
|
||
|
||
} else {
|
||
|
||
//
|
||
// Watch out for SAM returning the same member twice.
|
||
//
|
||
|
||
if ( (*Entry)->Action != AddMember ) {
|
||
Status = NERR_InternalError;
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// If this is info level 1 and the requested attributes are
|
||
// different than the current attributes,
|
||
// Remember to change the attributes.
|
||
//
|
||
|
||
if ( Level == 1 &&
|
||
(*Entry)->NewAttributes != OldAttributes[OldIndex] ) {
|
||
|
||
(*Entry)->OldAttributes = OldAttributes[OldIndex];
|
||
(*Entry)->Action = SetAttributesMember;
|
||
|
||
//
|
||
// This is either info level 0 or the level 1 attributes
|
||
// are the same as the existing attributes.
|
||
//
|
||
|
||
} else {
|
||
(*Entry)->Action = IgnoreMember;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// Loop through the list adding all new members.
|
||
// We do this in a separate loop to minimize the damage that happens
|
||
// should we get an error and not be able to recover.
|
||
//
|
||
|
||
for ( CurEntry = MemberList; CurEntry != NULL ; CurEntry=CurEntry->Next ) {
|
||
if ( CurEntry->Action == AddMember ) {
|
||
Status = SamAddMemberToGroup( GroupHandle,
|
||
CurEntry->RelativeId,
|
||
CurEntry->NewAttributes );
|
||
|
||
if ( !NT_SUCCESS( Status ) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppSetUsers: SamAddMemberToGroup returns %lX\n",
|
||
Status ));
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
CurEntry->Done = TRUE;
|
||
|
||
}
|
||
}
|
||
|
||
//
|
||
// Loop through the list deleting all old members and changing the
|
||
// attributes of all common members.
|
||
//
|
||
|
||
for ( CurEntry = MemberList; CurEntry != NULL ; CurEntry=CurEntry->Next ) {
|
||
|
||
if ( CurEntry->Action == RemoveMember ) {
|
||
Status = SamRemoveMemberFromGroup( GroupHandle,
|
||
CurEntry->RelativeId);
|
||
|
||
if ( !NT_SUCCESS( Status ) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppSetUsers: SamRemoveMemberFromGroup returns %lX\n",
|
||
Status ));
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
} else if ( CurEntry->Action == SetAttributesMember ) {
|
||
Status = SamSetMemberAttributesOfGroup( GroupHandle,
|
||
CurEntry->RelativeId,
|
||
CurEntry->NewAttributes);
|
||
|
||
if ( !NT_SUCCESS( Status ) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint((
|
||
"GrouppSetUsers: SamSetMemberAttributesOfGroup returns %lX\n",
|
||
Status ));
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
goto Cleanup;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
CurEntry->Done = TRUE;
|
||
}
|
||
|
||
//
|
||
// Delete the group if requested to do so.
|
||
//
|
||
|
||
if ( DeleteGroup ) {
|
||
|
||
Status = SamDeleteGroup( GroupHandle );
|
||
|
||
if ( !NT_SUCCESS( Status ) ) {
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppSetUsers: SamDeleteGroup returns %lX\n",
|
||
Status ));
|
||
}
|
||
NetStatus = NetpNtStatusToApiStatus( Status );
|
||
|
||
//
|
||
// Put the group memberships back the way they were.
|
||
//
|
||
goto Cleanup;
|
||
}
|
||
GroupHandle = NULL;
|
||
}
|
||
|
||
NetStatus = NERR_Success;
|
||
|
||
//
|
||
// Clean up.
|
||
//
|
||
|
||
Cleanup:
|
||
|
||
//
|
||
// Walk the member list cleaning up any damage we've done
|
||
//
|
||
|
||
for ( CurEntry = MemberList; CurEntry != NULL ; ) {
|
||
|
||
struct _MEMBER_DESCRIPTION *DelEntry;
|
||
|
||
if ( NetStatus != NERR_Success && CurEntry->Done ) {
|
||
switch (CurEntry->Action) {
|
||
case AddMember:
|
||
Status = SamRemoveMemberFromGroup( GroupHandle,
|
||
CurEntry->RelativeId );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
|
||
break;
|
||
|
||
case RemoveMember:
|
||
Status = SamAddMemberToGroup( GroupHandle,
|
||
CurEntry->RelativeId,
|
||
CurEntry->OldAttributes );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
|
||
break;
|
||
|
||
case SetAttributesMember:
|
||
Status = SamSetMemberAttributesOfGroup(
|
||
GroupHandle,
|
||
CurEntry->RelativeId,
|
||
CurEntry->OldAttributes );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
DelEntry = CurEntry;
|
||
CurEntry = CurEntry->Next;
|
||
|
||
NetpMemoryFree( DelEntry );
|
||
}
|
||
|
||
if ( NameStrings != NULL ) {
|
||
NetpMemoryFree( NameStrings );
|
||
}
|
||
|
||
if (NewRelativeIds != NULL) {
|
||
Status = SamFreeMemory( NewRelativeIds );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if (NewNameUse != NULL) {
|
||
Status = SamFreeMemory( NewNameUse );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if (OldNameUse != NULL) {
|
||
Status = SamFreeMemory( OldNameUse );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if (OldRelativeIds != NULL) {
|
||
Status = SamFreeMemory( OldRelativeIds );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if (OldAttributes != NULL) {
|
||
Status = SamFreeMemory( OldAttributes );
|
||
NetpAssert( NT_SUCCESS(Status) );
|
||
}
|
||
|
||
if (GroupHandle != NULL) {
|
||
(VOID) SamCloseHandle( GroupHandle );
|
||
}
|
||
|
||
UaspCloseDomain( DomainHandle );
|
||
|
||
if ( SamServerHandle != NULL ) {
|
||
(VOID) SamCloseHandle( SamServerHandle );
|
||
}
|
||
|
||
IF_DEBUG( UAS_DEBUG_GROUP ) {
|
||
NetpKdPrint(( "GrouppSetUsers: returns %ld\n", NetStatus ));
|
||
}
|
||
|
||
return NetStatus;
|
||
|
||
} // GrouppSetUsers
|