* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-/* $Id$
- *
+/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* PURPOSE: SAM interface library
* PROGRAMER: Eric Kohl
*/
-/* INCLUDES *****************************************************************/
-
#include "precomp.h"
+#define NTOS_MODE_USER
+#include <ndk/rtlfuncs.h>
+#include <ntsam.h>
+#include <sam_c.h>
+
+#include <wine/debug.h>
+
WINE_DEFAULT_DEBUG_CHANNEL(samlib);
+NTSTATUS
+WINAPI
+SystemFunction006(LPCSTR password,
+ LPSTR hash);
+
+NTSTATUS
+WINAPI
+SystemFunction007(PUNICODE_STRING string,
+ LPBYTE hash);
+
+NTSTATUS
+WINAPI
+SystemFunction012(const BYTE *in,
+ const BYTE *key,
+ LPBYTE out);
+
/* GLOBALS *******************************************************************/
}
+NTSTATUS
+SampCheckPassword(IN SAMPR_HANDLE UserHandle,
+ IN PUNICODE_STRING Password)
+{
+ USER_DOMAIN_PASSWORD_INFORMATION DomainPasswordInformation;
+ ULONG PasswordLength;
+ NTSTATUS Status;
+
+ TRACE("(%p %p)\n", UserHandle, Password);
+
+ /* Get the domain password information */
+ Status = SamrGetUserDomainPasswordInformation(UserHandle,
+ &DomainPasswordInformation);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SamrGetUserDomainPasswordInformation failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ PasswordLength = (ULONG)(Password->Length / sizeof(WCHAR));
+
+ /* Fail if the password is too short or too long */
+ if ((PasswordLength < DomainPasswordInformation.MinPasswordLength) ||
+ (PasswordLength > 256))
+ return STATUS_PASSWORD_RESTRICTION;
+
+ /* Check the password complexity */
+ if (DomainPasswordInformation.PasswordProperties & DOMAIN_PASSWORD_COMPLEX)
+ {
+ /* FIXME */
+ }
+
+ return STATUS_SUCCESS;
+}
+
+
NTSTATUS
NTAPI
SamAddMemberToAlias(IN SAM_HANDLE AliasHandle,
}
+NTSTATUS
+NTAPI
+SamAddMemberToGroup(IN SAM_HANDLE GroupHandle,
+ IN ULONG MemberId,
+ IN ULONG Attributes)
+{
+ NTSTATUS Status;
+
+ TRACE("SamAddMemberToGroup(%p %lu %lx)\n",
+ GroupHandle, MemberId, Attributes);
+
+ RpcTryExcept
+ {
+ Status = SamrAddMemberToGroup((SAMPR_HANDLE)GroupHandle,
+ MemberId,
+ Attributes);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamAddMultipleMembersToAlias(IN SAM_HANDLE AliasHandle,
+ IN PSID *MemberIds,
+ IN ULONG MemberCount)
+{
+ SAMPR_PSID_ARRAY Buffer;
+ NTSTATUS Status;
+
+ TRACE("SamAddMultipleMembersToAlias(%p %p %lu)\n",
+ AliasHandle, MemberIds, MemberCount);
+
+ if (MemberIds == NULL)
+ return STATUS_INVALID_PARAMETER_2;
+
+ Buffer.Count = MemberCount;
+ Buffer.Sids = (PSAMPR_SID_INFORMATION)MemberIds;
+
+ RpcTryExcept
+ {
+ Status = SamrAddMultipleMembersToAlias((SAMPR_HANDLE)AliasHandle,
+ &Buffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamChangePasswordUser(IN SAM_HANDLE UserHandle,
+ IN PUNICODE_STRING OldPassword,
+ IN PUNICODE_STRING NewPassword)
+{
+ ENCRYPTED_NT_OWF_PASSWORD OldNtPassword;
+ ENCRYPTED_NT_OWF_PASSWORD NewNtPassword;
+ ENCRYPTED_LM_OWF_PASSWORD OldLmPassword;
+ ENCRYPTED_LM_OWF_PASSWORD NewLmPassword;
+ OEM_STRING LmPwdString;
+ CHAR LmPwdBuffer[15];
+ BOOLEAN OldLmPasswordPresent = FALSE;
+ BOOLEAN NewLmPasswordPresent = FALSE;
+ NTSTATUS Status;
+
+ ENCRYPTED_LM_OWF_PASSWORD OldLmEncryptedWithNewLm;
+ ENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithOldLm;
+ ENCRYPTED_LM_OWF_PASSWORD OldNtEncryptedWithNewNt;
+ ENCRYPTED_LM_OWF_PASSWORD NewNtEncryptedWithOldNt;
+ PENCRYPTED_LM_OWF_PASSWORD pOldLmEncryptedWithNewLm = NULL;
+ PENCRYPTED_LM_OWF_PASSWORD pNewLmEncryptedWithOldLm = NULL;
+
+ /* Calculate the NT hash for the old password */
+ Status = SystemFunction007(OldPassword,
+ (LPBYTE)&OldNtPassword);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction007 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ /* Calculate the NT hash for the new password */
+ Status = SystemFunction007(NewPassword,
+ (LPBYTE)&NewNtPassword);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction007 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ /* Calculate the LM password and hash for the old password */
+ LmPwdString.Length = 15;
+ LmPwdString.MaximumLength = 15;
+ LmPwdString.Buffer = LmPwdBuffer;
+ ZeroMemory(LmPwdString.Buffer, LmPwdString.MaximumLength);
+
+ Status = RtlUpcaseUnicodeStringToOemString(&LmPwdString,
+ OldPassword,
+ FALSE);
+ if (NT_SUCCESS(Status))
+ {
+ /* Calculate the LM hash value of the password */
+ Status = SystemFunction006(LmPwdString.Buffer,
+ (LPSTR)&OldLmPassword);
+ if (NT_SUCCESS(Status))
+ {
+ OldLmPasswordPresent = TRUE;
+ }
+ }
+
+ /* Calculate the LM password and hash for the new password */
+ LmPwdString.Length = 15;
+ LmPwdString.MaximumLength = 15;
+ LmPwdString.Buffer = LmPwdBuffer;
+ ZeroMemory(LmPwdString.Buffer, LmPwdString.MaximumLength);
+
+ Status = RtlUpcaseUnicodeStringToOemString(&LmPwdString,
+ NewPassword,
+ FALSE);
+ if (NT_SUCCESS(Status))
+ {
+ /* Calculate the LM hash value of the password */
+ Status = SystemFunction006(LmPwdString.Buffer,
+ (LPSTR)&NewLmPassword);
+ if (NT_SUCCESS(Status))
+ {
+ NewLmPasswordPresent = TRUE;
+ }
+ }
+
+ if (OldLmPasswordPresent && NewLmPasswordPresent)
+ {
+ Status = SystemFunction012((const BYTE *)&OldLmPassword,
+ (const BYTE *)&NewLmPassword,
+ (LPBYTE)&OldLmEncryptedWithNewLm);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction012 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ Status = SystemFunction012((const BYTE *)&NewLmPassword,
+ (const BYTE *)&OldLmPassword,
+ (LPBYTE)&NewLmEncryptedWithOldLm);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction012 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ pOldLmEncryptedWithNewLm = &OldLmEncryptedWithNewLm;
+ pNewLmEncryptedWithOldLm = &NewLmEncryptedWithOldLm;
+ }
+
+ Status = SystemFunction012((const BYTE *)&OldNtPassword,
+ (const BYTE *)&NewNtPassword,
+ (LPBYTE)&OldNtEncryptedWithNewNt);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction012 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ Status = SystemFunction012((const BYTE *)&NewNtPassword,
+ (const BYTE *)&OldNtPassword,
+ (LPBYTE)&NewNtEncryptedWithOldNt);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction012 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ RpcTryExcept
+ {
+ Status = SamrChangePasswordUser((SAMPR_HANDLE)UserHandle,
+ OldLmPasswordPresent && NewLmPasswordPresent,
+ pOldLmEncryptedWithNewLm,
+ pNewLmEncryptedWithOldLm,
+ TRUE,
+ &OldNtEncryptedWithNewNt,
+ &NewNtEncryptedWithOldNt,
+ FALSE,
+ NULL,
+ FALSE,
+ NULL);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamChangePasswordUser2(IN PUNICODE_STRING ServerName,
+ IN PUNICODE_STRING UserName,
+ IN PUNICODE_STRING OldPassword,
+ IN PUNICODE_STRING NewPassword)
+{
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
+}
+
+
+NTSTATUS
+NTAPI
+SamChangePasswordUser3(IN PUNICODE_STRING ServerName,
+ IN PUNICODE_STRING UserName,
+ IN PUNICODE_STRING OldPassword,
+ IN PUNICODE_STRING NewPassword,
+ OUT PDOMAIN_PASSWORD_INFORMATION *EffectivePasswordPolicy,
+ OUT PUSER_PWD_CHANGE_FAILURE_INFORMATION *PasswordChangeFailureInfo)
+{
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
+}
+
+
NTSTATUS
NTAPI
SamCloseHandle(IN SAM_HANDLE SamHandle)
NTSTATUS
NTAPI
-SamConnect(IN OUT PUNICODE_STRING ServerName,
+SamConnect(IN OUT PUNICODE_STRING ServerName OPTIONAL,
OUT PSAM_HANDLE ServerHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes)
TRACE("SamCreateAliasInDomain(%p %p 0x%08x %p %p)\n",
DomainHandle, AccountName, DesiredAccess, AliasHandle, RelativeId);
+ *AliasHandle = NULL;
+ *RelativeId = 0;
+
RpcTryExcept
{
Status = SamrCreateAliasInDomain((SAMPR_HANDLE)DomainHandle,
TRACE("SamCreateGroupInDomain(%p %p 0x%08x %p %p)\n",
DomainHandle, AccountName, DesiredAccess, GroupHandle, RelativeId);
+ *GroupHandle = NULL;
+ *RelativeId = 0;
+
RpcTryExcept
{
Status = SamrCreateGroupInDomain((SAMPR_HANDLE)DomainHandle,
}
+NTSTATUS
+NTAPI
+SamCreateUser2InDomain(IN SAM_HANDLE DomainHandle,
+ IN PUNICODE_STRING AccountName,
+ IN ULONG AccountType,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PSAM_HANDLE UserHandle,
+ OUT PULONG GrantedAccess,
+ OUT PULONG RelativeId)
+{
+ NTSTATUS Status;
+
+ TRACE("SamCreateUser2InDomain(%p %p %lu 0x%08x %p %p %p)\n",
+ DomainHandle, AccountName, AccountType, DesiredAccess,
+ UserHandle, GrantedAccess, RelativeId);
+
+ *UserHandle = NULL;
+ *RelativeId = 0;
+
+ RpcTryExcept
+ {
+ Status = SamrCreateUser2InDomain((SAMPR_HANDLE)DomainHandle,
+ (PRPC_UNICODE_STRING)AccountName,
+ AccountType,
+ DesiredAccess,
+ (SAMPR_HANDLE *)UserHandle,
+ GrantedAccess,
+ RelativeId);
+
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
NTSTATUS
NTAPI
SamCreateUserInDomain(IN SAM_HANDLE DomainHandle,
TRACE("SamCreateUserInDomain(%p %p 0x%08x %p %p)\n",
DomainHandle, AccountName, DesiredAccess, UserHandle, RelativeId);
+ *UserHandle = NULL;
+ *RelativeId = 0;
+
RpcTryExcept
{
Status = SamrCreateUserInDomain((SAMPR_HANDLE)DomainHandle,
}
+NTSTATUS
+NTAPI
+SamDeleteAlias(IN SAM_HANDLE AliasHandle)
+{
+ SAMPR_HANDLE LocalAliasHandle;
+ NTSTATUS Status;
+
+ TRACE("SamDeleteAlias(%p)\n", AliasHandle);
+
+ LocalAliasHandle = (SAMPR_HANDLE)AliasHandle;
+
+ if (LocalAliasHandle == NULL)
+ return STATUS_INVALID_HANDLE;
+
+ RpcTryExcept
+ {
+ Status = SamrDeleteAlias(&LocalAliasHandle);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamDeleteGroup(IN SAM_HANDLE GroupHandle)
+{
+ SAMPR_HANDLE LocalGroupHandle;
+ NTSTATUS Status;
+
+ TRACE("SamDeleteGroup(%p)\n", GroupHandle);
+
+ LocalGroupHandle = (SAMPR_HANDLE)GroupHandle;
+
+ if (LocalGroupHandle == NULL)
+ return STATUS_INVALID_HANDLE;
+
+ RpcTryExcept
+ {
+ Status = SamrDeleteGroup(&LocalGroupHandle);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamDeleteUser(IN SAM_HANDLE UserHandle)
+{
+ SAMPR_HANDLE LocalUserHandle;
+ NTSTATUS Status;
+
+ TRACE("SamDeleteUser(%p)\n", UserHandle);
+
+ LocalUserHandle = (SAMPR_HANDLE)UserHandle;
+
+ if (LocalUserHandle == NULL)
+ return STATUS_INVALID_HANDLE;
+
+ RpcTryExcept
+ {
+ Status = SamrDeleteUser(&LocalUserHandle);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
NTSTATUS
NTAPI
SamEnumerateAliasesInDomain(IN SAM_HANDLE DomainHandle,
{
Status = SamrEnumerateAliasesInDomain((SAMPR_HANDLE)DomainHandle,
EnumerationContext,
- (PSAMPR_ENUMERATION_BUFFER *)&EnumBuffer,
+ &EnumBuffer,
PreferedMaximumLength,
CountReturned);
{
Status = SamrEnumerateDomainsInSamServer((SAMPR_HANDLE)ServerHandle,
EnumerationContext,
- (PSAMPR_ENUMERATION_BUFFER *)&EnumBuffer,
+ &EnumBuffer,
PreferedMaximumLength,
CountReturned);
{
Status = SamrEnumerateGroupsInDomain((SAMPR_HANDLE)DomainHandle,
EnumerationContext,
- (PSAMPR_ENUMERATION_BUFFER *)&EnumBuffer,
+ &EnumBuffer,
PreferedMaximumLength,
CountReturned);
if (EnumBuffer != NULL)
Status = SamrEnumerateUsersInDomain((SAMPR_HANDLE)DomainHandle,
EnumerationContext,
UserAccountControl,
- (PSAMPR_ENUMERATION_BUFFER *)&EnumBuffer,
+ &EnumBuffer,
PreferedMaximumLength,
CountReturned);
if (EnumBuffer != NULL)
SAMPR_ULONG_ARRAY Membership;
NTSTATUS Status;
- TRACE("SamAliasMembership(%p %ul %p %p %p)\n",
+ TRACE("SamAliasMembership(%p %lu %p %p %p)\n",
DomainHandle, PassedCount, Sids, MembershipCount, Aliases);
if (Sids == NULL ||
NTSTATUS
NTAPI
-SamGetMembersInAlias(IN SAM_HANDLE AliasHandle,
- OUT PSID **MemberIds,
- OUT PULONG MemberCount)
+SamGetCompatibilityMode(IN SAM_HANDLE ObjectHandle,
+ OUT PULONG Mode)
{
- SAMPR_PSID_ARRAY_OUT SidArray;
- NTSTATUS Status;
+ TRACE("(%p %p)\n", ObjectHandle, Mode);
- TRACE("SamGetMembersInAlias(%p %p %p)\n",
- AliasHandle, MemberIds, MemberCount);
-
- if ((MemberIds == NULL) ||
- (MemberCount == NULL))
+ if (Mode == NULL)
return STATUS_INVALID_PARAMETER;
- *MemberIds = NULL;
- *MemberCount = 0;
+ *Mode = SAM_SID_COMPATIBILITY_ALL;
- SidArray.Sids = NULL;
+ return STATUS_SUCCESS;
+}
+
+
+NTSTATUS
+NTAPI
+SamGetDisplayEnumerationIndex(IN SAM_HANDLE DomainHandle,
+ IN DOMAIN_DISPLAY_INFORMATION DisplayInformation,
+ IN PUNICODE_STRING Prefix,
+ OUT PULONG Index)
+{
+ NTSTATUS Status;
+
+ TRACE("(%p %lu %wZ %p)\n",
+ DomainHandle, DisplayInformation, Prefix, Index);
+
+ if ((Prefix == NULL) ||
+ (Index == NULL))
+ return STATUS_INVALID_PARAMETER;
RpcTryExcept
{
- Status = SamrGetMembersInAlias((SAMPR_HANDLE)AliasHandle,
+ Status = SamrGetDisplayEnumerationIndex2((SAMPR_HANDLE)DomainHandle,
+ DisplayInformation,
+ (PRPC_UNICODE_STRING)Prefix,
+ Index);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamGetGroupsForUser(IN SAM_HANDLE UserHandle,
+ OUT PGROUP_MEMBERSHIP *Groups,
+ OUT PULONG MembershipCount)
+{
+ PSAMPR_GET_GROUPS_BUFFER GroupsBuffer = NULL;
+ NTSTATUS Status;
+
+ TRACE("SamGetGroupsForUser(%p %p %p)\n",
+ UserHandle, Groups, MembershipCount);
+
+ RpcTryExcept
+ {
+ Status = SamrGetGroupsForUser((SAMPR_HANDLE)UserHandle,
+ &GroupsBuffer);
+ if (NT_SUCCESS(Status))
+ {
+ *Groups = GroupsBuffer->Groups;
+ *MembershipCount = GroupsBuffer->MembershipCount;
+
+ MIDL_user_free(GroupsBuffer);
+ }
+ else
+ {
+ if (GroupsBuffer != NULL)
+ {
+ if (GroupsBuffer->Groups != NULL)
+ MIDL_user_free(GroupsBuffer->Groups);
+
+ MIDL_user_free(GroupsBuffer);
+ }
+ }
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamGetMembersInAlias(IN SAM_HANDLE AliasHandle,
+ OUT PSID **MemberIds,
+ OUT PULONG MemberCount)
+{
+ SAMPR_PSID_ARRAY_OUT SidArray;
+ NTSTATUS Status;
+
+ TRACE("SamGetMembersInAlias(%p %p %p)\n",
+ AliasHandle, MemberIds, MemberCount);
+
+ if ((MemberIds == NULL) ||
+ (MemberCount == NULL))
+ return STATUS_INVALID_PARAMETER;
+
+ *MemberIds = NULL;
+ *MemberCount = 0;
+
+ SidArray.Sids = NULL;
+
+ RpcTryExcept
+ {
+ Status = SamrGetMembersInAlias((SAMPR_HANDLE)AliasHandle,
&SidArray);
if (NT_SUCCESS(Status))
{
}
+NTSTATUS
+NTAPI
+SamGetMembersInGroup(IN SAM_HANDLE GroupHandle,
+ OUT PULONG *MemberIds,
+ OUT PULONG *Attributes,
+ OUT PULONG MemberCount)
+{
+ PSAMPR_GET_MEMBERS_BUFFER MembersBuffer = NULL;
+ NTSTATUS Status;
+
+ TRACE("SamGetMembersInGroup(%p %p %p %p)\n",
+ GroupHandle, MemberIds, Attributes, MemberCount);
+
+ RpcTryExcept
+ {
+ Status = SamrGetMembersInGroup((SAMPR_HANDLE)GroupHandle,
+ &MembersBuffer);
+ if (NT_SUCCESS(Status))
+ {
+ *MemberIds = MembersBuffer->Members;
+ *Attributes = MembersBuffer->Attributes;
+ *MemberCount = MembersBuffer->MemberCount;
+
+ MIDL_user_free(MembersBuffer);
+ }
+ else
+ {
+ if (MembersBuffer != NULL)
+ {
+ if (MembersBuffer->Members != NULL)
+ MIDL_user_free(MembersBuffer->Members);
+
+ if (MembersBuffer->Attributes != NULL)
+ MIDL_user_free(MembersBuffer->Attributes);
+
+ MIDL_user_free(MembersBuffer);
+ }
+ }
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
NTSTATUS
NTAPI
SamLookupDomainInSamServer(IN SAM_HANDLE ServerHandle,
}
+NTSTATUS
+NTAPI
+SamLookupIdsInDomain(IN SAM_HANDLE DomainHandle,
+ IN ULONG Count,
+ IN PULONG RelativeIds,
+ OUT PUNICODE_STRING *Names,
+ OUT PSID_NAME_USE *Use OPTIONAL)
+{
+ SAMPR_RETURNED_USTRING_ARRAY NamesBuffer = {0, NULL};
+ SAMPR_ULONG_ARRAY UseBuffer = {0, NULL};
+ ULONG i;
+ NTSTATUS Status;
+
+ TRACE("SamLookupIdsInDomain(%p %lu %p %p %p)\n",
+ DomainHandle, Count, RelativeIds, Names, Use);
+
+ *Names = NULL;
+
+ if (Use != NULL)
+ *Use = NULL;
+
+ RpcTryExcept
+ {
+ Status = SamrLookupIdsInDomain((SAMPR_HANDLE)DomainHandle,
+ Count,
+ RelativeIds,
+ &NamesBuffer,
+ &UseBuffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (NT_SUCCESS(Status))
+ {
+ *Names = midl_user_allocate(Count * sizeof(RPC_UNICODE_STRING));
+ if (*Names == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto done;
+ }
+
+ for (i = 0; i < Count; i++)
+ {
+ (*Names)[i].Buffer = midl_user_allocate(NamesBuffer.Element[i].MaximumLength);
+ if ((*Names)[i].Buffer == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto done;
+ }
+ }
+
+ for (i = 0; i < Count; i++)
+ {
+ (*Names)[i].Length = NamesBuffer.Element[i].Length;
+ (*Names)[i].MaximumLength = NamesBuffer.Element[i].MaximumLength;
+
+ RtlCopyMemory((*Names)[i].Buffer,
+ NamesBuffer.Element[i].Buffer,
+ NamesBuffer.Element[i].Length);
+ }
+
+ if (Use != NULL)
+ {
+ *Use = midl_user_allocate(Count * sizeof(SID_NAME_USE));
+ if (*Use == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto done;
+ }
+
+ RtlCopyMemory(*Use,
+ UseBuffer.Element,
+ Count * sizeof(SID_NAME_USE));
+ }
+ }
+
+done:
+ if (!NT_SUCCESS(Status))
+ {
+ if (*Names != NULL)
+ {
+ for (i = 0; i < Count; i++)
+ {
+ if ((*Names)[i].Buffer != NULL)
+ midl_user_free((*Names)[i].Buffer);
+ }
+
+ midl_user_free(*Names);
+ }
+
+ if (Use != NULL && *Use != NULL)
+ midl_user_free(*Use);
+ }
+
+ if (NamesBuffer.Element != NULL)
+ {
+ for (i = 0; i < NamesBuffer.Count; i++)
+ {
+ if (NamesBuffer.Element[i].Buffer != NULL)
+ midl_user_free(NamesBuffer.Element[i].Buffer);
+ }
+
+ midl_user_free(NamesBuffer.Element);
+ }
+
+ if (UseBuffer.Element != NULL)
+ midl_user_free(UseBuffer.Element);
+
+ return 0;
+}
+
+
NTSTATUS
NTAPI
SamLookupNamesInDomain(IN SAM_HANDLE DomainHandle,
OUT PULONG *RelativeIds,
OUT PSID_NAME_USE *Use)
{
- UNIMPLEMENTED;
- return STATUS_NOT_IMPLEMENTED;
+ SAMPR_ULONG_ARRAY RidBuffer = {0, NULL};
+ SAMPR_ULONG_ARRAY UseBuffer = {0, NULL};
+ NTSTATUS Status;
+
+ TRACE("SamLookupNamesInDomain(%p %lu %p %p %p)\n",
+ DomainHandle, Count, Names, RelativeIds, Use);
+
+ *RelativeIds = NULL;
+ *Use = NULL;
+
+ RpcTryExcept
+ {
+ Status = SamrLookupNamesInDomain((SAMPR_HANDLE)DomainHandle,
+ Count,
+ (PRPC_UNICODE_STRING)Names,
+ &RidBuffer,
+ &UseBuffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (NT_SUCCESS(Status))
+ {
+ *RelativeIds = midl_user_allocate(Count * sizeof(ULONG));
+ if (*RelativeIds == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto done;
+ }
+
+ *Use = midl_user_allocate(Count * sizeof(SID_NAME_USE));
+ if (*Use == NULL)
+ {
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto done;
+ }
+
+ RtlCopyMemory(*RelativeIds,
+ RidBuffer.Element,
+ Count * sizeof(ULONG));
+
+ RtlCopyMemory(*Use,
+ UseBuffer.Element,
+ Count * sizeof(SID_NAME_USE));
+ }
+
+done:
+ if (!NT_SUCCESS(Status))
+ {
+ if (*RelativeIds != NULL)
+ midl_user_free(*RelativeIds);
+
+ if (*Use != NULL)
+ midl_user_free(*Use);
+ }
+
+ if (RidBuffer.Element != NULL)
+ midl_user_free(RidBuffer.Element);
+
+ if (UseBuffer.Element != NULL)
+ midl_user_free(UseBuffer.Element);
+
+ return Status;
}
}
+NTSTATUS
+NTAPI
+SamQueryDisplayInformation(IN SAM_HANDLE DomainHandle,
+ IN DOMAIN_DISPLAY_INFORMATION DisplayInformation,
+ IN ULONG Index,
+ IN ULONG EntryCount,
+ IN ULONG PreferredMaximumLength,
+ OUT PULONG TotalAvailable,
+ OUT PULONG TotalReturned,
+ OUT PULONG ReturnedEntryCount,
+ OUT PVOID *SortedBuffer)
+{
+ SAMPR_DISPLAY_INFO_BUFFER LocalBuffer;
+ NTSTATUS Status;
+
+ TRACE("(%p %lu %lu %lu %lu %p %p %p %p)\n",
+ DomainHandle, DisplayInformation, Index, EntryCount,
+ PreferredMaximumLength, TotalAvailable, TotalReturned,
+ ReturnedEntryCount, SortedBuffer);
+
+ if ((TotalAvailable == NULL) ||
+ (TotalReturned == NULL) ||
+ (ReturnedEntryCount == NULL) ||
+ (SortedBuffer == NULL))
+ return STATUS_INVALID_PARAMETER;
+
+ RpcTryExcept
+ {
+ Status = SamrQueryDisplayInformation3((SAMPR_HANDLE)DomainHandle,
+ DisplayInformation,
+ Index,
+ EntryCount,
+ PreferredMaximumLength,
+ TotalAvailable,
+ TotalReturned,
+ &LocalBuffer);
+ if (NT_SUCCESS(Status))
+ {
+ switch (DisplayInformation)
+ {
+ case DomainDisplayUser:
+ *ReturnedEntryCount = LocalBuffer.UserInformation.EntriesRead;
+ *SortedBuffer = LocalBuffer.UserInformation.Buffer;
+ break;
+
+ case DomainDisplayMachine:
+ *ReturnedEntryCount = LocalBuffer.MachineInformation.EntriesRead;
+ *SortedBuffer = LocalBuffer.MachineInformation.Buffer;
+ break;
+
+ case DomainDisplayGroup:
+ *ReturnedEntryCount = LocalBuffer.GroupInformation.EntriesRead;
+ *SortedBuffer = LocalBuffer.GroupInformation.Buffer;
+ break;
+
+ case DomainDisplayOemUser:
+ *ReturnedEntryCount = LocalBuffer.OemUserInformation.EntriesRead;
+ *SortedBuffer = LocalBuffer.OemUserInformation.Buffer;
+ break;
+
+ case DomainDisplayOemGroup:
+ *ReturnedEntryCount = LocalBuffer.OemGroupInformation.EntriesRead;
+ *SortedBuffer = LocalBuffer.OemGroupInformation.Buffer;
+ break;
+
+ case DomainDisplayServer:
+ /* FIXME */
+ break;
+ }
+ }
+ else
+ {
+ *ReturnedEntryCount = 0;
+ *SortedBuffer = NULL;
+ }
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
NTSTATUS
NTAPI
SamQueryInformationAlias(IN SAM_HANDLE AliasHandle,
}
+NTSTATUS
+NTAPI
+SamQuerySecurityObject(IN SAM_HANDLE ObjectHandle,
+ IN SECURITY_INFORMATION SecurityInformation,
+ OUT PSECURITY_DESCRIPTOR *SecurityDescriptor)
+{
+ PSAMPR_SR_SECURITY_DESCRIPTOR SamSecurityDescriptor = NULL;
+ NTSTATUS Status;
+
+ TRACE("SamQuerySecurityObject(%p %lu %p)\n",
+ ObjectHandle, SecurityInformation, SecurityDescriptor);
+
+ *SecurityDescriptor = NULL;
+
+ RpcTryExcept
+ {
+ Status = SamrQuerySecurityObject((SAMPR_HANDLE)ObjectHandle,
+ SecurityInformation,
+ &SamSecurityDescriptor);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ TRACE("SamSecurityDescriptor: %p\n", SamSecurityDescriptor);
+
+ if (SamSecurityDescriptor != NULL)
+ {
+ TRACE("SamSecurityDescriptor->Length: %lu\n", SamSecurityDescriptor->Length);
+ TRACE("SamSecurityDescriptor->SecurityDescriptor: %p\n", SamSecurityDescriptor->SecurityDescriptor);
+
+ *SecurityDescriptor = SamSecurityDescriptor->SecurityDescriptor;
+
+ midl_user_free(SamSecurityDescriptor);
+ }
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamRemoveMemberFromAlias(IN SAM_HANDLE AliasHandle,
+ IN PSID MemberId)
+{
+ NTSTATUS Status;
+
+ TRACE("SamRemoveMemberFromAlias(%p %ul)\n",
+ AliasHandle, MemberId);
+
+ RpcTryExcept
+ {
+ Status = SamrRemoveMemberFromAlias((SAMPR_HANDLE)AliasHandle,
+ MemberId);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamRemoveMemberFromForeignDomain(IN SAM_HANDLE DomainHandle,
+ IN PSID MemberId)
+{
+ NTSTATUS Status;
+
+ TRACE("SamRemoveMemberFromForeignDomain(%p %ul)\n",
+ DomainHandle, MemberId);
+
+ RpcTryExcept
+ {
+ Status = SamrRemoveMemberFromForeignDomain((SAMPR_HANDLE)DomainHandle,
+ MemberId);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamRemoveMemberFromGroup(IN SAM_HANDLE GroupHandle,
+ IN ULONG MemberId)
+{
+ NTSTATUS Status;
+
+ TRACE("SamRemoveMemberFromGroup(%p %ul)\n",
+ GroupHandle, MemberId);
+
+ RpcTryExcept
+ {
+ Status = SamrRemoveMemberFromGroup((SAMPR_HANDLE)GroupHandle,
+ MemberId);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamRemoveMultipleMembersFromAlias(IN SAM_HANDLE AliasHandle,
+ IN PSID *MemberIds,
+ IN ULONG MemberCount)
+{
+ SAMPR_PSID_ARRAY Buffer;
+ NTSTATUS Status;
+
+ TRACE("SamRemoveMultipleMembersFromAlias(%p %p %lu)\n",
+ AliasHandle, MemberIds, MemberCount);
+
+ if (MemberIds == NULL)
+ return STATUS_INVALID_PARAMETER_2;
+
+ Buffer.Count = MemberCount;
+ Buffer.Sids = (PSAMPR_SID_INFORMATION)MemberIds;
+
+ RpcTryExcept
+ {
+ Status = SamrRemoveMultipleMembersFromAlias((SAMPR_HANDLE)AliasHandle,
+ &Buffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamRidToSid(IN SAM_HANDLE ObjectHandle,
+ IN ULONG Rid,
+ OUT PSID *Sid)
+{
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
+}
+
+
NTSTATUS
NTAPI
SamSetInformationAlias(IN SAM_HANDLE AliasHandle,
IN USER_INFORMATION_CLASS UserInformationClass,
IN PVOID Buffer)
{
+ PSAMPR_USER_SET_PASSWORD_INFORMATION PasswordBuffer;
+ SAMPR_USER_INTERNAL1_INFORMATION Internal1Buffer;
+ USER_ALL_INFORMATION InternalAllBuffer;
+ OEM_STRING LmPwdString;
+ CHAR LmPwdBuffer[15];
NTSTATUS Status;
TRACE("SamSetInformationUser(%p %lu %p)\n",
UserHandle, UserInformationClass, Buffer);
+ if (UserInformationClass == UserSetPasswordInformation)
+ {
+ PasswordBuffer = (PSAMPR_USER_SET_PASSWORD_INFORMATION)Buffer;
+
+ Status = SampCheckPassword(UserHandle,
+ (PUNICODE_STRING)&PasswordBuffer->Password);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SampCheckPassword failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ /* Calculate the NT hash value of the passord */
+ Status = SystemFunction007((PUNICODE_STRING)&PasswordBuffer->Password,
+ (LPBYTE)&Internal1Buffer.EncryptedNtOwfPassword);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction007 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ Internal1Buffer.NtPasswordPresent = TRUE;
+ Internal1Buffer.LmPasswordPresent = FALSE;
+
+ /* Build the LM password */
+ LmPwdString.Length = 15;
+ LmPwdString.MaximumLength = 15;
+ LmPwdString.Buffer = LmPwdBuffer;
+ ZeroMemory(LmPwdString.Buffer, LmPwdString.MaximumLength);
+
+ Status = RtlUpcaseUnicodeStringToOemString(&LmPwdString,
+ (PUNICODE_STRING)&PasswordBuffer->Password,
+ FALSE);
+ if (NT_SUCCESS(Status))
+ {
+ /* Calculate the LM hash value of the password */
+ Status = SystemFunction006(LmPwdString.Buffer,
+ (LPSTR)&Internal1Buffer.EncryptedLmOwfPassword);
+ if (NT_SUCCESS(Status))
+ Internal1Buffer.LmPasswordPresent = TRUE;
+ }
+
+ Internal1Buffer.PasswordExpired = PasswordBuffer->PasswordExpired;
+
+ RpcTryExcept
+ {
+ Status = SamrSetInformationUser((SAMPR_HANDLE)UserHandle,
+ UserInternal1Information,
+ (PVOID)&Internal1Buffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SamrSetInformation() failed (Status 0x%08lx)\n", Status);
+ }
+
+ return Status;
+ }
+ else if (UserInformationClass == UserAllInformation)
+ {
+ RtlCopyMemory(&InternalAllBuffer,
+ Buffer,
+ sizeof(USER_ALL_INFORMATION));
+
+ if (InternalAllBuffer.WhichFields & (USER_ALL_LMPASSWORDPRESENT | USER_ALL_NTPASSWORDPRESENT))
+ {
+ if (InternalAllBuffer.WhichFields & USER_ALL_OWFPASSWORD)
+ {
+ /* Check NT password hash */
+ if (InternalAllBuffer.WhichFields & USER_ALL_NTPASSWORDPRESENT)
+ {
+ if (InternalAllBuffer.NtPassword.Length != sizeof(ENCRYPTED_NT_OWF_PASSWORD))
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ /* Check LM password hash */
+ if (InternalAllBuffer.WhichFields & USER_ALL_LMPASSWORDPRESENT)
+ {
+ if (InternalAllBuffer.LmPassword.Length != sizeof(ENCRYPTED_LM_OWF_PASSWORD))
+ return STATUS_INVALID_PARAMETER;
+ }
+ }
+ else
+ {
+ /*
+ * Only allow the NT password to be set.
+ * The LM password will be created here.
+ */
+ if (InternalAllBuffer.WhichFields & USER_ALL_LMPASSWORDPRESENT)
+ {
+ TRACE("Do not try to set a clear text LM password!\n");
+ return STATUS_INVALID_PARAMETER;
+ }
+
+ if (InternalAllBuffer.WhichFields & USER_ALL_NTPASSWORDPRESENT)
+ {
+ Status = SampCheckPassword(UserHandle,
+ &InternalAllBuffer.NtPassword);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SampCheckPassword failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ /* Calculate the NT password hash */
+ Status = SystemFunction007((PUNICODE_STRING)&InternalAllBuffer.NtPassword,
+ (LPBYTE)&Internal1Buffer.EncryptedNtOwfPassword);
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SystemFunction007 failed (Status 0x%08lx)\n", Status);
+ return Status;
+ }
+
+ InternalAllBuffer.NtPasswordPresent = TRUE;
+ InternalAllBuffer.LmPasswordPresent = FALSE;
+
+ InternalAllBuffer.NtPassword.Length = sizeof(ENCRYPTED_NT_OWF_PASSWORD);
+ InternalAllBuffer.NtPassword.MaximumLength = sizeof(ENCRYPTED_NT_OWF_PASSWORD);
+ InternalAllBuffer.NtPassword.Buffer = (LPWSTR)&Internal1Buffer.EncryptedNtOwfPassword;
+
+ /* Build the LM password */
+ LmPwdString.Length = 15;
+ LmPwdString.MaximumLength = 15;
+ LmPwdString.Buffer = LmPwdBuffer;
+ ZeroMemory(LmPwdString.Buffer, LmPwdString.MaximumLength);
+
+ Status = RtlUpcaseUnicodeStringToOemString(&LmPwdString,
+ (PUNICODE_STRING)&InternalAllBuffer.NtPassword,
+ FALSE);
+ if (NT_SUCCESS(Status))
+ {
+ /* Calculate the LM password hash */
+ Status = SystemFunction006(LmPwdString.Buffer,
+ (LPSTR)&Internal1Buffer.EncryptedLmOwfPassword);
+ if (NT_SUCCESS(Status))
+ {
+ InternalAllBuffer.WhichFields |= USER_ALL_LMPASSWORDPRESENT;
+ InternalAllBuffer.LmPasswordPresent = TRUE;
+
+ InternalAllBuffer.LmPassword.Length = sizeof(ENCRYPTED_LM_OWF_PASSWORD);
+ InternalAllBuffer.LmPassword.MaximumLength = sizeof(ENCRYPTED_LM_OWF_PASSWORD);
+ InternalAllBuffer.LmPassword.Buffer = (LPWSTR)&Internal1Buffer.EncryptedLmOwfPassword;
+ }
+ }
+ }
+ }
+ }
+
+ RpcTryExcept
+ {
+ Status = SamrSetInformationUser((SAMPR_HANDLE)UserHandle,
+ UserAllInformation,
+ (PVOID)&InternalAllBuffer);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ if (!NT_SUCCESS(Status))
+ {
+ TRACE("SamrSetInformation() failed (Status 0x%08lx)\n", Status);
+ }
+
+ return Status;
+ }
+
RpcTryExcept
{
Status = SamrSetInformationUser((SAMPR_HANDLE)UserHandle,
}
+NTSTATUS
+NTAPI
+SamSetMemberAttributesOfGroup(IN SAM_HANDLE GroupHandle,
+ IN ULONG MemberId,
+ IN ULONG Attributes)
+{
+ NTSTATUS Status;
+
+ TRACE("SamSetMemberAttributesOfGroup(%p %lu 0x%lx)\n",
+ GroupHandle, MemberId, Attributes);
+
+ RpcTryExcept
+ {
+ Status = SamrSetMemberAttributesOfGroup((SAMPR_HANDLE)GroupHandle,
+ MemberId,
+ Attributes);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
+}
+
+
+NTSTATUS
+NTAPI
+SamSetSecurityObject(IN SAM_HANDLE ObjectHandle,
+ IN SECURITY_INFORMATION SecurityInformation,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor)
+{
+ SAMPR_SR_SECURITY_DESCRIPTOR DescriptorToPass;
+ ULONG Length;
+ NTSTATUS Status;
+
+ TRACE("SamSetSecurityObject(%p %lu %p)\n",
+ ObjectHandle, SecurityInformation, SecurityDescriptor);
+
+ /* Retrieve the length of the relative security descriptor */
+ Length = 0;
+ Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
+ NULL,
+ &Length);
+ if (Status != STATUS_BUFFER_TOO_SMALL)
+ return STATUS_INVALID_PARAMETER;
+
+
+ /* Allocate a buffer for the security descriptor */
+ DescriptorToPass.Length = Length;
+ DescriptorToPass.SecurityDescriptor = MIDL_user_allocate(Length);
+ if (DescriptorToPass.SecurityDescriptor == NULL)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ /* Convert the given security descriptor to a relative security descriptor */
+ Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
+ (PSECURITY_DESCRIPTOR)DescriptorToPass.SecurityDescriptor,
+ &Length);
+ if (!NT_SUCCESS(Status))
+ goto done;
+
+ RpcTryExcept
+ {
+ Status = SamrSetSecurityObject((SAMPR_HANDLE)ObjectHandle,
+ SecurityInformation,
+ &DescriptorToPass);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+done:
+ if (DescriptorToPass.SecurityDescriptor != NULL)
+ MIDL_user_free(DescriptorToPass.SecurityDescriptor);
+
+ return Status;
+}
+
+
NTSTATUS
NTAPI
SamShutdownSamServer(IN SAM_HANDLE ServerHandle)
{
- UNIMPLEMENTED;
- return STATUS_NOT_IMPLEMENTED;
+ NTSTATUS Status;
+
+ TRACE("(%p)\n", ServerHandle);
+
+ RpcTryExcept
+ {
+ Status = SamrShutdownSamServer((SAMPR_HANDLE)ServerHandle);
+ }
+ RpcExcept(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = I_RpcMapWin32Status(RpcExceptionCode());
+ }
+ RpcEndExcept;
+
+ return Status;
}
/* EOF */