reactos/dll/win32/samlib/samlib.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2004 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19 /*
  20  * COPYRIGHT:         See COPYING in the top level directory
  21  * PROJECT:           ReactOS system libraries
  22  * PURPOSE:           SAM interface library
  23  * FILE:              lib/samlib/samlib.c
  24  * PROGRAMER:         Eric Kohl
  25  */
  26
  27 /* INCLUDES *****************************************************************/
  28
  29 #include "precomp.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(samlib);
  32
  33 NTSTATUS
  34 WINAPI
  35 SystemFunction006(LPCSTR password,
  36                   LPSTR hash);
  37
  38 NTSTATUS
  39 WINAPI
  40 SystemFunction007(PUNICODE_STRING string,
  41                   LPBYTE hash);
  42
  43 /* GLOBALS *******************************************************************/
  44
  45
  46 /* FUNCTIONS *****************************************************************/
  47
  48 void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
  49 {
  50     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
  51 }
  52
  53
  54 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
  55 {
  56     HeapFree(GetProcessHeap(), 0, ptr);
  57 }
  58
  59
  60 handle_t __RPC_USER
  61 PSAMPR_SERVER_NAME_bind(PSAMPR_SERVER_NAME pszSystemName)
  62 {
  63     handle_t hBinding = NULL;
  64     LPWSTR pszStringBinding;
  65     RPC_STATUS status;
  66
  67     TRACE("PSAMPR_SERVER_NAME_bind() called\n");
  68
  69     status = RpcStringBindingComposeW(NULL,
  70                                       L"ncacn_np",
  71                                       pszSystemName,
  72                                       L"\\pipe\\samr",
  73                                       NULL,
  74                                       &pszStringBinding);
  75     if (status)
  76     {
  77         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
  78         return NULL;
  79     }
  80
  81     /* Set the binding handle that will be used to bind to the server. */
  82     status = RpcBindingFromStringBindingW(pszStringBinding,
  83                                           &hBinding);
  84     if (status)
  85     {
  86         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
  87     }
  88
  89     status = RpcStringFreeW(&pszStringBinding);
  90     if (status)
  91     {
  92 //        TRACE("RpcStringFree returned 0x%x\n", status);
  93     }
  94
  95     return hBinding;
  96 }
  97
  98
  99 void __RPC_USER
 100 PSAMPR_SERVER_NAME_unbind(PSAMPR_SERVER_NAME pszSystemName,
 101                           handle_t hBinding)
 102 {
 103     RPC_STATUS status;
 104
 105     TRACE("PSAMPR_SERVER_NAME_unbind() called\n");
 106
 107     status = RpcBindingFree(&hBinding);
 108     if (status)
 109     {
 110         TRACE("RpcBindingFree returned 0x%x\n", status);
 111     }
 112 }
 113
 114
 115 NTSTATUS
 116 NTAPI
 117 SamAddMemberToAlias(IN SAM_HANDLE AliasHandle,
 118                     IN PSID MemberId)
 119 {
 120     NTSTATUS Status;
 121
 122     TRACE("SamAddMemberToAlias(%p %p)\n",
 123           AliasHandle, MemberId);
 124
 125     RpcTryExcept
 126     {
 127         Status = SamrAddMemberToAlias((SAMPR_HANDLE)AliasHandle,
 128                                       (PRPC_SID)MemberId);
 129     }
 130     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 131     {
 132         Status = I_RpcMapWin32Status(RpcExceptionCode());
 133     }
 134     RpcEndExcept;
 135
 136     return Status;
 137 }
 138
 139
 140 NTSTATUS
 141 NTAPI
 142 SamAddMemberToGroup(IN SAM_HANDLE GroupHandle,
 143                     IN ULONG MemberId,
 144                     IN ULONG Attributes)
 145 {
 146     NTSTATUS Status;
 147
 148     TRACE("SamAddMemberToGroup(%p %lu %lx)\n",
 149           GroupHandle, MemberId, Attributes);
 150
 151     RpcTryExcept
 152     {
 153         Status = SamrAddMemberToGroup((SAMPR_HANDLE)GroupHandle,
 154                                       MemberId,
 155                                       Attributes);
 156     }
 157     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 158     {
 159         Status = I_RpcMapWin32Status(RpcExceptionCode());
 160     }
 161     RpcEndExcept;
 162
 163     return Status;
 164 }
 165
 166
 167 NTSTATUS
 168 NTAPI
 169 SamAddMultipleMembersToAlias(IN SAM_HANDLE AliasHandle,
 170                              IN PSID *MemberIds,
 171                              IN ULONG MemberCount)
 172 {
 173     SAMPR_PSID_ARRAY Buffer;
 174     NTSTATUS Status;
 175
 176     TRACE("SamAddMultipleMembersToAlias(%p %p %lu)\n",
 177           AliasHandle, MemberIds, MemberCount);
 178
 179     if (MemberIds == NULL)
 180         return STATUS_INVALID_PARAMETER_2;
 181
 182     Buffer.Count = MemberCount;
 183     Buffer.Sids = (PSAMPR_SID_INFORMATION)MemberIds;
 184
 185     RpcTryExcept
 186     {
 187         Status = SamrAddMultipleMembersToAlias((SAMPR_HANDLE)AliasHandle,
 188                                                &Buffer);
 189     }
 190     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 191     {
 192         Status = I_RpcMapWin32Status(RpcExceptionCode());
 193     }
 194     RpcEndExcept;
 195
 196     return Status;
 197 }
 198
 199
 200 NTSTATUS
 201 NTAPI
 202 SamChangePasswordUser(IN SAM_HANDLE UserHandle,
 203                       IN PUNICODE_STRING OldPassword,
 204                       IN PUNICODE_STRING NewPassword)
 205 {
 206     ENCRYPTED_NT_OWF_PASSWORD OldNtPassword;
 207     ENCRYPTED_NT_OWF_PASSWORD NewNtPassword;
 208     ENCRYPTED_LM_OWF_PASSWORD OldLmPassword;
 209     ENCRYPTED_LM_OWF_PASSWORD NewLmPassword;
 210     OEM_STRING LmPwdString;
 211     CHAR LmPwdBuffer[15];
 212     BOOLEAN OldLmPasswordPresent = FALSE;
 213     BOOLEAN NewLmPasswordPresent = FALSE;
 214     NTSTATUS Status;
 215
 216     /* Calculate the NT hash for the old password */
 217     Status = SystemFunction007(OldPassword,
 218                                (LPBYTE)&OldNtPassword);
 219     if (!NT_SUCCESS(Status))
 220     {
 221         TRACE("SystemFunction007 failed (Status 0x%08lx)\n", Status);
 222         return Status;
 223     }
 224
 225     /* Calculate the NT hash for the new password */
 226     Status = SystemFunction007(NewPassword,
 227                                (LPBYTE)&NewNtPassword);
 228     if (!NT_SUCCESS(Status))
 229     {
 230         TRACE("SystemFunction007 failed (Status 0x%08lx)\n", Status);
 231         return Status;
 232     }
 233
 234     /* Calculate the LM password and hash for the old password */
 235     LmPwdString.Length = 15;
 236     LmPwdString.MaximumLength = 15;
 237     LmPwdString.Buffer = LmPwdBuffer;
 238     ZeroMemory(LmPwdString.Buffer, LmPwdString.MaximumLength);
 239
 240     Status = RtlUpcaseUnicodeStringToOemString(&LmPwdString,
 241                                                OldPassword,
 242                                                FALSE);
 243     if (NT_SUCCESS(Status))
 244     {
 245         /* Calculate the LM hash value of the password */
 246         Status = SystemFunction006(LmPwdString.Buffer,
 247                                    (LPSTR)&OldLmPassword);
 248         if (NT_SUCCESS(Status))
 249         {
 250             OldLmPasswordPresent = TRUE;
 251         }
 252     }
 253
 254     /* Calculate the LM password and hash for the new password */
 255     LmPwdString.Length = 15;
 256     LmPwdString.MaximumLength = 15;
 257     LmPwdString.Buffer = LmPwdBuffer;
 258     ZeroMemory(LmPwdString.Buffer, LmPwdString.MaximumLength);
 259
 260     Status = RtlUpcaseUnicodeStringToOemString(&LmPwdString,
 261                                                NewPassword,
 262                                                FALSE);
 263     if (NT_SUCCESS(Status))
 264     {
 265         /* Calculate the LM hash value of the password */
 266         Status = SystemFunction006(LmPwdString.Buffer,
 267                                    (LPSTR)&NewLmPassword);
 268         if (NT_SUCCESS(Status))
 269         {
 270             NewLmPasswordPresent = TRUE;
 271         }
 272     }
 273
 274     RpcTryExcept
 275     {
 276         Status = SamrChangePasswordUser((SAMPR_HANDLE)UserHandle,
 277                                         OldLmPasswordPresent && NewLmPasswordPresent,
 278                                         &OldLmPassword,
 279                                         &NewLmPassword,
 280                                         TRUE,
 281                                         &OldNtPassword,
 282                                         &NewNtPassword,
 283                                         FALSE,
 284                                         NULL,
 285                                         FALSE,
 286                                         NULL);
 287     }
 288     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 289     {
 290         Status = I_RpcMapWin32Status(RpcExceptionCode());
 291     }
 292     RpcEndExcept;
 293
 294     return Status;
 295 }
 296
 297
 298 NTSTATUS
 299 NTAPI
 300 SamChangePasswordUser2(IN PUNICODE_STRING ServerName,
 301                        IN PUNICODE_STRING UserName,
 302                        IN PUNICODE_STRING OldPassword,
 303                        IN PUNICODE_STRING NewPassword)
 304 {
 305     UNIMPLEMENTED;
 306     return STATUS_NOT_IMPLEMENTED;
 307 }
 308
 309
 310 NTSTATUS
 311 NTAPI
 312 SamChangePasswordUser3(IN PUNICODE_STRING ServerName,
 313                        IN PUNICODE_STRING UserName,
 314                        IN PUNICODE_STRING OldPassword,
 315                        IN PUNICODE_STRING NewPassword,
 316                        OUT PDOMAIN_PASSWORD_INFORMATION *EffectivePasswordPolicy,
 317                        OUT PUSER_PWD_CHANGE_FAILURE_INFORMATION *PasswordChangeFailureInfo)
 318 {
 319     UNIMPLEMENTED;
 320     return STATUS_NOT_IMPLEMENTED;
 321 }
 322
 323
 324 NTSTATUS
 325 NTAPI
 326 SamCloseHandle(IN SAM_HANDLE SamHandle)
 327 {
 328     NTSTATUS Status;
 329
 330     TRACE("SamCloseHandle(%p)\n", SamHandle);
 331
 332     RpcTryExcept
 333     {
 334         Status = SamrCloseHandle((SAMPR_HANDLE *)&SamHandle);
 335     }
 336     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 337     {
 338         Status = I_RpcMapWin32Status(RpcExceptionCode());
 339     }
 340     RpcEndExcept;
 341
 342     return Status;
 343 }
 344
 345
 346 NTSTATUS
 347 NTAPI
 348 SamConnect(IN OUT PUNICODE_STRING ServerName OPTIONAL,
 349            OUT PSAM_HANDLE ServerHandle,
 350            IN ACCESS_MASK DesiredAccess,
 351            IN POBJECT_ATTRIBUTES ObjectAttributes)
 352 {
 353     NTSTATUS Status;
 354
 355     TRACE("SamConnect(%p %p 0x%08x %p)\n",
 356           ServerName, ServerHandle, DesiredAccess, ObjectAttributes);
 357
 358     RpcTryExcept
 359     {
 360         Status = SamrConnect((PSAMPR_SERVER_NAME)ServerName,
 361                              (SAMPR_HANDLE *)ServerHandle,
 362                              DesiredAccess);
 363     }
 364     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 365     {
 366         Status = I_RpcMapWin32Status(RpcExceptionCode());
 367     }
 368     RpcEndExcept;
 369
 370     return Status;
 371 }
 372
 373
 374 NTSTATUS
 375 NTAPI
 376 SamCreateAliasInDomain(IN SAM_HANDLE DomainHandle,
 377                        IN PUNICODE_STRING AccountName,
 378                        IN ACCESS_MASK DesiredAccess,
 379                        OUT PSAM_HANDLE AliasHandle,
 380                        OUT PULONG RelativeId)
 381 {
 382     NTSTATUS Status;
 383
 384     TRACE("SamCreateAliasInDomain(%p %p 0x%08x %p %p)\n",
 385           DomainHandle, AccountName, DesiredAccess, AliasHandle, RelativeId);
 386
 387     *AliasHandle = NULL;
 388     *RelativeId = 0;
 389
 390     RpcTryExcept
 391     {
 392         Status = SamrCreateAliasInDomain((SAMPR_HANDLE)DomainHandle,
 393                                          (PRPC_UNICODE_STRING)AccountName,
 394                                          DesiredAccess,
 395                                          (SAMPR_HANDLE *)AliasHandle,
 396                                          RelativeId);
 397     }
 398     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 399     {
 400         Status = I_RpcMapWin32Status(RpcExceptionCode());
 401     }
 402     RpcEndExcept;
 403
 404     return Status;
 405 }
 406
 407
 408 NTSTATUS
 409 NTAPI
 410 SamCreateGroupInDomain(IN SAM_HANDLE DomainHandle,
 411                        IN PUNICODE_STRING AccountName,
 412                        IN ACCESS_MASK DesiredAccess,
 413                        OUT PSAM_HANDLE GroupHandle,
 414                        OUT PULONG RelativeId)
 415 {
 416     NTSTATUS Status;
 417
 418     TRACE("SamCreateGroupInDomain(%p %p 0x%08x %p %p)\n",
 419           DomainHandle, AccountName, DesiredAccess, GroupHandle, RelativeId);
 420
 421     *GroupHandle = NULL;
 422     *RelativeId = 0;
 423
 424     RpcTryExcept
 425     {
 426         Status = SamrCreateGroupInDomain((SAMPR_HANDLE)DomainHandle,
 427                                          (PRPC_UNICODE_STRING)AccountName,
 428                                          DesiredAccess,
 429                                          (SAMPR_HANDLE *)GroupHandle,
 430                                          RelativeId);
 431     }
 432     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 433     {
 434         Status = I_RpcMapWin32Status(RpcExceptionCode());
 435     }
 436     RpcEndExcept;
 437
 438     return Status;
 439 }
 440
 441
 442 NTSTATUS
 443 NTAPI
 444 SamCreateUser2InDomain(IN SAM_HANDLE DomainHandle,
 445                        IN PUNICODE_STRING AccountName,
 446                        IN ULONG AccountType,
 447                        IN ACCESS_MASK DesiredAccess,
 448                        OUT PSAM_HANDLE UserHandle,
 449                        OUT PULONG GrantedAccess,
 450                        OUT PULONG RelativeId)
 451 {
 452     NTSTATUS Status;
 453
 454     TRACE("SamCreateUser2InDomain(%p %p %lu 0x%08x %p %p %p)\n",
 455           DomainHandle, AccountName, AccountType, DesiredAccess,
 456           UserHandle, GrantedAccess, RelativeId);
 457
 458     *UserHandle = NULL;
 459     *RelativeId = 0;
 460
 461     RpcTryExcept
 462     {
 463         Status = SamrCreateUser2InDomain((SAMPR_HANDLE)DomainHandle,
 464                                          (PRPC_UNICODE_STRING)AccountName,
 465                                          AccountType,
 466                                          DesiredAccess,
 467                                          (SAMPR_HANDLE *)UserHandle,
 468                                          GrantedAccess,
 469                                          RelativeId);
 470
 471     }
 472     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 473     {
 474         Status = I_RpcMapWin32Status(RpcExceptionCode());
 475     }
 476     RpcEndExcept;
 477
 478     return Status;
 479 }
 480
 481
 482 NTSTATUS
 483 NTAPI
 484 SamCreateUserInDomain(IN SAM_HANDLE DomainHandle,
 485                       IN PUNICODE_STRING AccountName,
 486                       IN ACCESS_MASK DesiredAccess,
 487                       OUT PSAM_HANDLE UserHandle,
 488                       OUT PULONG RelativeId)
 489 {
 490     NTSTATUS Status;
 491
 492     TRACE("SamCreateUserInDomain(%p %p 0x%08x %p %p)\n",
 493           DomainHandle, AccountName, DesiredAccess, UserHandle, RelativeId);
 494
 495     *UserHandle = NULL;
 496     *RelativeId = 0;
 497
 498     RpcTryExcept
 499     {
 500         Status = SamrCreateUserInDomain((SAMPR_HANDLE)DomainHandle,
 501                                         (PRPC_UNICODE_STRING)AccountName,
 502                                         DesiredAccess,
 503                                         (SAMPR_HANDLE *)UserHandle,
 504                                         RelativeId);
 505     }
 506     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 507     {
 508         Status = I_RpcMapWin32Status(RpcExceptionCode());
 509     }
 510     RpcEndExcept;
 511
 512     return Status;
 513 }
 514
 515
 516 NTSTATUS
 517 NTAPI
 518 SamDeleteAlias(IN SAM_HANDLE AliasHandle)
 519 {
 520     SAMPR_HANDLE LocalAliasHandle;
 521     NTSTATUS Status;
 522
 523     TRACE("SamDeleteAlias(%p)\n", AliasHandle);
 524
 525     LocalAliasHandle = (SAMPR_HANDLE)AliasHandle;
 526
 527     if (LocalAliasHandle == NULL)
 528         return STATUS_INVALID_HANDLE;
 529
 530     RpcTryExcept
 531     {
 532         Status = SamrDeleteAlias(&LocalAliasHandle);
 533     }
 534     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 535     {
 536         Status = I_RpcMapWin32Status(RpcExceptionCode());
 537     }
 538     RpcEndExcept;
 539
 540     return Status;
 541 }
 542
 543
 544 NTSTATUS
 545 NTAPI
 546 SamDeleteGroup(IN SAM_HANDLE GroupHandle)
 547 {
 548     SAMPR_HANDLE LocalGroupHandle;
 549     NTSTATUS Status;
 550
 551     TRACE("SamDeleteGroup(%p)\n", GroupHandle);
 552
 553     LocalGroupHandle = (SAMPR_HANDLE)GroupHandle;
 554
 555     if (LocalGroupHandle == NULL)
 556         return STATUS_INVALID_HANDLE;
 557
 558     RpcTryExcept
 559     {
 560         Status = SamrDeleteGroup(&LocalGroupHandle);
 561     }
 562     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 563     {
 564         Status = I_RpcMapWin32Status(RpcExceptionCode());
 565     }
 566     RpcEndExcept;
 567
 568     return Status;
 569 }
 570
 571
 572 NTSTATUS
 573 NTAPI
 574 SamDeleteUser(IN SAM_HANDLE UserHandle)
 575 {
 576     SAMPR_HANDLE LocalUserHandle;
 577     NTSTATUS Status;
 578
 579     TRACE("SamDeleteUser(%p)\n", UserHandle);
 580
 581     LocalUserHandle = (SAMPR_HANDLE)UserHandle;
 582
 583     if (LocalUserHandle == NULL)
 584         return STATUS_INVALID_HANDLE;
 585
 586     RpcTryExcept
 587     {
 588         Status = SamrDeleteUser(&LocalUserHandle);
 589     }
 590     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 591     {
 592         Status = I_RpcMapWin32Status(RpcExceptionCode());
 593     }
 594     RpcEndExcept;
 595
 596     return Status;
 597 }
 598
 599
 600 NTSTATUS
 601 NTAPI
 602 SamEnumerateAliasesInDomain(IN SAM_HANDLE DomainHandle,
 603                             IN OUT PSAM_ENUMERATE_HANDLE EnumerationContext,
 604                             OUT PVOID *Buffer,
 605                             IN ULONG PreferedMaximumLength,
 606                             OUT PULONG CountReturned)
 607 {
 608     PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
 609     NTSTATUS Status;
 610
 611     TRACE("SamEnumerateAliasesInDomain(%p %p %p %lu %p)\n",
 612           DomainHandle, EnumerationContext, Buffer, PreferedMaximumLength,
 613           CountReturned);
 614
 615     if ((EnumerationContext == NULL) ||
 616         (Buffer == NULL) ||
 617         (CountReturned == NULL))
 618         return STATUS_INVALID_PARAMETER;
 619
 620     *Buffer = NULL;
 621
 622     RpcTryExcept
 623     {
 624         Status = SamrEnumerateAliasesInDomain((SAMPR_HANDLE)DomainHandle,
 625                                               EnumerationContext,
 626                                               &EnumBuffer,
 627                                               PreferedMaximumLength,
 628                                               CountReturned);
 629
 630         if (EnumBuffer != NULL)
 631         {
 632             if (EnumBuffer->Buffer != NULL)
 633             {
 634                 *Buffer = EnumBuffer->Buffer;
 635             }
 636
 637             midl_user_free(EnumBuffer);
 638         }
 639     }
 640     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 641     {
 642         Status = I_RpcMapWin32Status(RpcExceptionCode());
 643     }
 644     RpcEndExcept;
 645
 646     return Status;
 647 }
 648
 649
 650 NTSTATUS
 651 NTAPI
 652 SamEnumerateDomainsInSamServer(IN SAM_HANDLE ServerHandle,
 653                                IN OUT PSAM_ENUMERATE_HANDLE EnumerationContext,
 654                                OUT PVOID *Buffer,
 655                                IN ULONG PreferedMaximumLength,
 656                                OUT PULONG CountReturned)
 657 {
 658     PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
 659     NTSTATUS Status;
 660
 661     TRACE("SamEnumerateDomainsInSamServer(%p %p %p %lu %p)\n",
 662           ServerHandle, EnumerationContext, Buffer, PreferedMaximumLength,
 663           CountReturned);
 664
 665     if ((EnumerationContext == NULL) ||
 666         (Buffer == NULL) ||
 667         (CountReturned == NULL))
 668         return STATUS_INVALID_PARAMETER;
 669
 670     *Buffer = NULL;
 671
 672     RpcTryExcept
 673     {
 674         Status = SamrEnumerateDomainsInSamServer((SAMPR_HANDLE)ServerHandle,
 675                                                  EnumerationContext,
 676                                                  &EnumBuffer,
 677                                                  PreferedMaximumLength,
 678                                                  CountReturned);
 679
 680         if (EnumBuffer != NULL)
 681         {
 682             if (EnumBuffer->Buffer != NULL)
 683             {
 684                 *Buffer = EnumBuffer->Buffer;
 685             }
 686
 687             midl_user_free(EnumBuffer);
 688         }
 689     }
 690     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 691     {
 692         Status = I_RpcMapWin32Status(RpcExceptionCode());
 693     }
 694     RpcEndExcept;
 695
 696     return Status;
 697 }
 698
 699
 700 NTSTATUS
 701 NTAPI
 702 SamEnumerateGroupsInDomain(IN SAM_HANDLE DomainHandle,
 703                            IN OUT PSAM_ENUMERATE_HANDLE EnumerationContext,
 704                            IN PVOID *Buffer,
 705                            IN ULONG PreferedMaximumLength,
 706                            OUT PULONG CountReturned)
 707 {
 708     PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
 709     NTSTATUS Status;
 710
 711     TRACE("SamEnumerateGroupsInDomain(%p %p %p %lu %p)\n",
 712           DomainHandle, EnumerationContext, Buffer,
 713           PreferedMaximumLength, CountReturned);
 714
 715     if (EnumerationContext == NULL || Buffer == NULL || CountReturned == NULL)
 716         return STATUS_INVALID_PARAMETER;
 717
 718     *Buffer = NULL;
 719
 720     RpcTryExcept
 721     {
 722         Status = SamrEnumerateGroupsInDomain((SAMPR_HANDLE)DomainHandle,
 723                                              EnumerationContext,
 724                                              &EnumBuffer,
 725                                              PreferedMaximumLength,
 726                                              CountReturned);
 727         if (EnumBuffer != NULL)
 728         {
 729             if (EnumBuffer->Buffer != NULL)
 730                 *Buffer = EnumBuffer->Buffer;
 731
 732             midl_user_free(EnumBuffer);
 733         }
 734     }
 735     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 736     {
 737         Status = I_RpcMapWin32Status(RpcExceptionCode());
 738     }
 739     RpcEndExcept;
 740
 741     return Status;
 742 }
 743
 744
 745 NTSTATUS
 746 NTAPI
 747 SamEnumerateUsersInDomain(IN SAM_HANDLE DomainHandle,
 748                           IN OUT PSAM_ENUMERATE_HANDLE EnumerationContext,
 749                           IN ULONG UserAccountControl,
 750                           OUT PVOID *Buffer,
 751                           IN ULONG PreferedMaximumLength,
 752                           OUT PULONG CountReturned)
 753 {
 754     PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
 755     NTSTATUS Status;
 756
 757     TRACE("SamEnumerateUsersInDomain(%p %p %lx %p %lu %p)\n",
 758           DomainHandle, EnumerationContext, UserAccountControl, Buffer,
 759           PreferedMaximumLength, CountReturned);
 760
 761     if (EnumerationContext == NULL || Buffer == NULL || CountReturned == NULL)
 762         return STATUS_INVALID_PARAMETER;
 763
 764     *Buffer = NULL;
 765
 766     RpcTryExcept
 767     {
 768         Status = SamrEnumerateUsersInDomain((SAMPR_HANDLE)DomainHandle,
 769                                             EnumerationContext,
 770                                             UserAccountControl,
 771                                             &EnumBuffer,
 772                                             PreferedMaximumLength,
 773                                             CountReturned);
 774         if (EnumBuffer != NULL)
 775         {
 776             if (EnumBuffer->Buffer != NULL)
 777             {
 778                 *Buffer = EnumBuffer->Buffer;
 779             }
 780
 781             midl_user_free(EnumBuffer);
 782         }
 783
 784     }
 785     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 786     {
 787         Status = I_RpcMapWin32Status(RpcExceptionCode());
 788     }
 789     RpcEndExcept;
 790
 791     return Status;
 792 }
 793
 794
 795 NTSTATUS
 796 NTAPI
 797 SamFreeMemory(IN PVOID Buffer)
 798 {
 799     if (Buffer != NULL)
 800         midl_user_free(Buffer);
 801
 802     return STATUS_SUCCESS;
 803 }
 804
 805
 806 NTSTATUS
 807 NTAPI
 808 SamGetAliasMembership(IN SAM_HANDLE DomainHandle,
 809                       IN ULONG PassedCount,
 810                       IN PSID *Sids,
 811                       OUT PULONG MembershipCount,
 812                       OUT PULONG *Aliases)
 813 {
 814     SAMPR_PSID_ARRAY SidArray;
 815     SAMPR_ULONG_ARRAY Membership;
 816     NTSTATUS Status;
 817
 818     TRACE("SamAliasMembership(%p %lu %p %p %p)\n",
 819           DomainHandle, PassedCount, Sids, MembershipCount, Aliases);
 820
 821     if (Sids == NULL ||
 822         MembershipCount == NULL ||
 823         Aliases == NULL)
 824         return STATUS_INVALID_PARAMETER;
 825
 826     Membership.Element = NULL;
 827
 828     RpcTryExcept
 829     {
 830         SidArray.Count = PassedCount;
 831         SidArray.Sids = (PSAMPR_SID_INFORMATION)Sids;
 832
 833         Status = SamrGetAliasMembership((SAMPR_HANDLE)DomainHandle,
 834                                         &SidArray,
 835                                         &Membership);
 836         if (NT_SUCCESS(Status))
 837         {
 838             *MembershipCount = Membership.Count;
 839             *Aliases = Membership.Element;
 840         }
 841         else
 842         {
 843             if (Membership.Element != NULL)
 844                 midl_user_free(Membership.Element);
 845         }
 846     }
 847     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 848     {
 849         Status = I_RpcMapWin32Status(RpcExceptionCode());
 850     }
 851     RpcEndExcept;
 852
 853     return Status;
 854 }
 855
 856
 857 NTSTATUS
 858 NTAPI
 859 SamGetCompatibilityMode(IN SAM_HANDLE ObjectHandle,
 860                         OUT PULONG Mode)
 861 {
 862     TRACE("(%p %p)\n", ObjectHandle, Mode);
 863
 864     if (Mode == NULL)
 865         return STATUS_INVALID_PARAMETER;
 866
 867     *Mode = SAM_SID_COMPATIBILITY_ALL;
 868
 869     return STATUS_SUCCESS;
 870 }
 871
 872
 873 NTSTATUS
 874 NTAPI
 875 SamGetGroupsForUser(IN SAM_HANDLE UserHandle,
 876                     OUT PGROUP_MEMBERSHIP *Groups,
 877                     OUT PULONG MembershipCount)
 878 {
 879     PSAMPR_GET_GROUPS_BUFFER GroupsBuffer = NULL;
 880     NTSTATUS Status;
 881
 882     TRACE("SamGetGroupsForUser(%p %p %p)\n",
 883           UserHandle, Groups, MembershipCount);
 884
 885     RpcTryExcept
 886     {
 887         Status = SamrGetGroupsForUser((SAMPR_HANDLE)UserHandle,
 888                                       &GroupsBuffer);
 889         if (NT_SUCCESS(Status))
 890         {
 891             *Groups = GroupsBuffer->Groups;
 892             *MembershipCount = GroupsBuffer->MembershipCount;
 893
 894             MIDL_user_free(GroupsBuffer);
 895         }
 896         else
 897         {
 898             if (GroupsBuffer != NULL)
 899             {
 900                 if (GroupsBuffer->Groups != NULL)
 901                     MIDL_user_free(GroupsBuffer->Groups);
 902
 903                 MIDL_user_free(GroupsBuffer);
 904             }
 905         }
 906     }
 907     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 908     {
 909         Status = I_RpcMapWin32Status(RpcExceptionCode());
 910     }
 911     RpcEndExcept;
 912
 913     return Status;
 914 }
 915
 916
 917 NTSTATUS
 918 NTAPI
 919 SamGetMembersInAlias(IN SAM_HANDLE AliasHandle,
 920                      OUT PSID **MemberIds,
 921                      OUT PULONG MemberCount)
 922 {
 923     SAMPR_PSID_ARRAY_OUT SidArray;
 924     NTSTATUS Status;
 925
 926     TRACE("SamGetMembersInAlias(%p %p %p)\n",
 927           AliasHandle, MemberIds, MemberCount);
 928
 929     if ((MemberIds == NULL) ||
 930         (MemberCount == NULL))
 931         return STATUS_INVALID_PARAMETER;
 932
 933     *MemberIds = NULL;
 934     *MemberCount = 0;
 935
 936     SidArray.Sids = NULL;
 937
 938     RpcTryExcept
 939     {
 940         Status = SamrGetMembersInAlias((SAMPR_HANDLE)AliasHandle,
 941                                        &SidArray);
 942         if (NT_SUCCESS(Status))
 943         {
 944             *MemberCount = SidArray.Count;
 945             *MemberIds = (PSID *)SidArray.Sids;
 946         }
 947
 948     }
 949     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 950     {
 951         Status = I_RpcMapWin32Status(RpcExceptionCode());
 952     }
 953     RpcEndExcept;
 954
 955     return Status;
 956 }
 957
 958
 959 NTSTATUS
 960 NTAPI
 961 SamGetMembersInGroup(IN SAM_HANDLE GroupHandle,
 962                      OUT PULONG *MemberIds,
 963                      OUT PULONG *Attributes,
 964                      OUT PULONG MemberCount)
 965 {
 966     PSAMPR_GET_MEMBERS_BUFFER MembersBuffer = NULL;
 967     NTSTATUS Status;
 968
 969     TRACE("SamGetMembersInGroup(%p %p %p %p)\n",
 970           GroupHandle, MemberIds, Attributes, MemberCount);
 971
 972     RpcTryExcept
 973     {
 974         Status = SamrGetMembersInGroup((SAMPR_HANDLE)GroupHandle,
 975                                        &MembersBuffer);
 976         if (NT_SUCCESS(Status))
 977         {
 978             *MemberIds = MembersBuffer->Members;
 979             *Attributes = MembersBuffer->Attributes;
 980             *MemberCount = MembersBuffer->MemberCount;
 981
 982             MIDL_user_free(MembersBuffer);
 983         }
 984         else
 985         {
 986             if (MembersBuffer != NULL)
 987             {
 988                 if (MembersBuffer->Members != NULL)
 989                     MIDL_user_free(MembersBuffer->Members);
 990
 991                 if (MembersBuffer->Attributes != NULL)
 992                     MIDL_user_free(MembersBuffer->Attributes);
 993
 994                 MIDL_user_free(MembersBuffer);
 995             }
 996         }
 997     }
 998     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 999     {
1000         Status = I_RpcMapWin32Status(RpcExceptionCode());
1001     }
1002     RpcEndExcept;
1003
1004     return Status;
1005 }
1006
1007
1008 NTSTATUS
1009 NTAPI
1010 SamLookupDomainInSamServer(IN SAM_HANDLE ServerHandle,
1011                            IN PUNICODE_STRING Name,
1012                            OUT PSID *DomainId)
1013 {
1014     NTSTATUS Status;
1015
1016     TRACE("SamLookupDomainInSamServer(%p %p %p)\n",
1017           ServerHandle, Name, DomainId);
1018
1019     RpcTryExcept
1020     {
1021         Status = SamrLookupDomainInSamServer((SAMPR_HANDLE)ServerHandle,
1022                                              (PRPC_UNICODE_STRING)Name,
1023                                              (PRPC_SID *)DomainId);
1024     }
1025     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1026     {
1027         Status = I_RpcMapWin32Status(RpcExceptionCode());
1028     }
1029     RpcEndExcept;
1030
1031     return Status;
1032 }
1033
1034
1035 NTSTATUS
1036 NTAPI
1037 SamLookupIdsInDomain(IN SAM_HANDLE DomainHandle,
1038                      IN ULONG Count,
1039                      IN PULONG RelativeIds,
1040                      OUT PUNICODE_STRING *Names,
1041                      OUT PSID_NAME_USE *Use OPTIONAL)
1042 {
1043     SAMPR_RETURNED_USTRING_ARRAY NamesBuffer = {0, NULL};
1044     SAMPR_ULONG_ARRAY UseBuffer = {0, NULL};
1045     ULONG i;
1046     NTSTATUS Status;
1047
1048     TRACE("SamLookupIdsInDomain(%p %lu %p %p %p)\n",
1049           DomainHandle, Count, RelativeIds, Names, Use);
1050
1051     *Names = NULL;
1052
1053     if (Use != NULL)
1054         *Use = NULL;
1055
1056     RpcTryExcept
1057     {
1058         Status = SamrLookupIdsInDomain((SAMPR_HANDLE)DomainHandle,
1059                                        Count,
1060                                        RelativeIds,
1061                                        &NamesBuffer,
1062                                        &UseBuffer);
1063     }
1064     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1065     {
1066         Status = I_RpcMapWin32Status(RpcExceptionCode());
1067     }
1068     RpcEndExcept;
1069
1070     if (NT_SUCCESS(Status))
1071     {
1072         *Names = midl_user_allocate(Count * sizeof(RPC_UNICODE_STRING));
1073         if (*Names == NULL)
1074         {
1075             Status = STATUS_INSUFFICIENT_RESOURCES;
1076             goto done;
1077         }
1078
1079         for (i = 0; i < Count; i++)
1080         {
1081             (*Names)[i].Buffer = midl_user_allocate(NamesBuffer.Element[i].MaximumLength);
1082             if ((*Names)[i].Buffer == NULL)
1083             {
1084                 Status = STATUS_INSUFFICIENT_RESOURCES;
1085                 goto done;
1086             }
1087         }
1088
1089         for (i = 0; i < Count; i++)
1090         {
1091             (*Names)[i].Length = NamesBuffer.Element[i].Length;
1092             (*Names)[i].MaximumLength = NamesBuffer.Element[i].MaximumLength;
1093
1094             RtlCopyMemory((*Names)[i].Buffer,
1095                           NamesBuffer.Element[i].Buffer,
1096                           NamesBuffer.Element[i].Length);
1097         }
1098
1099         if (Use != NULL)
1100         {
1101             *Use = midl_user_allocate(Count * sizeof(SID_NAME_USE));
1102             if (*Use == NULL)
1103             {
1104                 Status = STATUS_INSUFFICIENT_RESOURCES;
1105                 goto done;
1106             }
1107
1108             RtlCopyMemory(*Use,
1109                           UseBuffer.Element,
1110                           Count * sizeof(SID_NAME_USE));
1111         }
1112     }
1113
1114 done:
1115     if (!NT_SUCCESS(Status))
1116     {
1117         if (*Names != NULL)
1118         {
1119             for (i = 0; i < Count; i++)
1120             {
1121                 if ((*Names)[i].Buffer != NULL)
1122                     midl_user_free((*Names)[i].Buffer);
1123             }
1124
1125             midl_user_free(*Names);
1126         }
1127
1128         if (Use != NULL && *Use != NULL)
1129             midl_user_free(*Use);
1130     }
1131
1132     if (NamesBuffer.Element != NULL)
1133     {
1134         for (i = 0; i < NamesBuffer.Count; i++)
1135         {
1136             if (NamesBuffer.Element[i].Buffer != NULL)
1137                 midl_user_free(NamesBuffer.Element[i].Buffer);
1138         }
1139
1140         midl_user_free(NamesBuffer.Element);
1141     }
1142
1143     if (UseBuffer.Element != NULL)
1144         midl_user_free(UseBuffer.Element);
1145
1146     return 0;
1147 }
1148
1149
1150 NTSTATUS
1151 NTAPI
1152 SamLookupNamesInDomain(IN SAM_HANDLE DomainHandle,
1153                        IN ULONG Count,
1154                        IN PUNICODE_STRING Names,
1155                        OUT PULONG *RelativeIds,
1156                        OUT PSID_NAME_USE *Use)
1157 {
1158     SAMPR_ULONG_ARRAY RidBuffer = {0, NULL};
1159     SAMPR_ULONG_ARRAY UseBuffer = {0, NULL};
1160     NTSTATUS Status;
1161
1162     TRACE("SamLookupNamesInDomain(%p %lu %p %p %p)\n",
1163           DomainHandle, Count, Names, RelativeIds, Use);
1164
1165     *RelativeIds = NULL;
1166     *Use = NULL;
1167
1168     RpcTryExcept
1169     {
1170         Status = SamrLookupNamesInDomain((SAMPR_HANDLE)DomainHandle,
1171                                          Count,
1172                                          (PRPC_UNICODE_STRING)Names,
1173                                          &RidBuffer,
1174                                          &UseBuffer);
1175     }
1176     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1177     {
1178         Status = I_RpcMapWin32Status(RpcExceptionCode());
1179     }
1180     RpcEndExcept;
1181
1182     if (NT_SUCCESS(Status))
1183     {
1184         *RelativeIds = midl_user_allocate(Count * sizeof(ULONG));
1185         if (*RelativeIds == NULL)
1186         {
1187             Status = STATUS_INSUFFICIENT_RESOURCES;
1188             goto done;
1189         }
1190
1191         *Use = midl_user_allocate(Count * sizeof(SID_NAME_USE));
1192         if (*Use == NULL)
1193         {
1194             Status = STATUS_INSUFFICIENT_RESOURCES;
1195             goto done;
1196         }
1197
1198         RtlCopyMemory(*RelativeIds,
1199                       RidBuffer.Element,
1200                       Count * sizeof(ULONG));
1201
1202         RtlCopyMemory(*Use,
1203                       UseBuffer.Element,
1204                       Count * sizeof(SID_NAME_USE));
1205     }
1206
1207 done:
1208     if (!NT_SUCCESS(Status))
1209     {
1210         if (*RelativeIds != NULL)
1211             midl_user_free(*RelativeIds);
1212
1213         if (*Use != NULL)
1214             midl_user_free(*Use);
1215     }
1216
1217     if (RidBuffer.Element != NULL)
1218         midl_user_free(RidBuffer.Element);
1219
1220     if (UseBuffer.Element != NULL)
1221         midl_user_free(UseBuffer.Element);
1222
1223     return Status;
1224 }
1225
1226
1227 NTSTATUS
1228 NTAPI
1229 SamOpenAlias(IN SAM_HANDLE DomainHandle,
1230              IN ACCESS_MASK DesiredAccess,
1231              IN ULONG AliasId,
1232              OUT PSAM_HANDLE AliasHandle)
1233 {
1234     NTSTATUS Status;
1235
1236     TRACE("SamOpenAlias(%p 0x%08x %lx %p)\n",
1237           DomainHandle, DesiredAccess, AliasId, AliasHandle);
1238
1239     RpcTryExcept
1240     {
1241         Status = SamrOpenAlias((SAMPR_HANDLE)DomainHandle,
1242                                DesiredAccess,
1243                                AliasId,
1244                                (SAMPR_HANDLE *)AliasHandle);
1245     }
1246     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1247     {
1248         Status = I_RpcMapWin32Status(RpcExceptionCode());
1249     }
1250     RpcEndExcept;
1251
1252     return Status;
1253 }
1254
1255
1256 NTSTATUS
1257 NTAPI
1258 SamOpenDomain(IN SAM_HANDLE ServerHandle,
1259               IN ACCESS_MASK DesiredAccess,
1260               IN PSID DomainId,
1261               OUT PSAM_HANDLE DomainHandle)
1262 {
1263     NTSTATUS Status;
1264
1265     TRACE("SamOpenDomain(%p 0x%08x %p %p)\n",
1266           ServerHandle, DesiredAccess, DomainId, DomainHandle);
1267
1268     RpcTryExcept
1269     {
1270         Status = SamrOpenDomain((SAMPR_HANDLE)ServerHandle,
1271                                 DesiredAccess,
1272                                 (PRPC_SID)DomainId,
1273                                 (SAMPR_HANDLE *)DomainHandle);
1274     }
1275     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1276     {
1277         Status = I_RpcMapWin32Status(RpcExceptionCode());
1278     }
1279     RpcEndExcept;
1280
1281     return Status;
1282 }
1283
1284
1285 NTSTATUS
1286 NTAPI
1287 SamOpenGroup(IN SAM_HANDLE DomainHandle,
1288              IN ACCESS_MASK DesiredAccess,
1289              IN ULONG GroupId,
1290              OUT PSAM_HANDLE GroupHandle)
1291 {
1292     NTSTATUS Status;
1293
1294     TRACE("SamOpenGroup(%p 0x%08x %p %p)\n",
1295           DomainHandle, DesiredAccess, GroupId, GroupHandle);
1296
1297     RpcTryExcept
1298     {
1299         Status = SamrOpenGroup((SAMPR_HANDLE)DomainHandle,
1300                                DesiredAccess,
1301                                GroupId,
1302                                (SAMPR_HANDLE *)GroupHandle);
1303     }
1304     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1305     {
1306         Status = I_RpcMapWin32Status(RpcExceptionCode());
1307     }
1308     RpcEndExcept;
1309
1310     return Status;
1311 }
1312
1313
1314 NTSTATUS
1315 NTAPI
1316 SamOpenUser(IN SAM_HANDLE DomainHandle,
1317             IN ACCESS_MASK DesiredAccess,
1318             IN ULONG UserId,
1319             OUT PSAM_HANDLE UserHandle)
1320 {
1321     NTSTATUS Status;
1322
1323     TRACE("SamOpenUser(%p 0x%08x %lx %p)\n",
1324           DomainHandle, DesiredAccess, UserId, UserHandle);
1325
1326     RpcTryExcept
1327     {
1328         Status = SamrOpenUser((SAMPR_HANDLE)DomainHandle,
1329                               DesiredAccess,
1330                               UserId,
1331                               (SAMPR_HANDLE *)UserHandle);
1332     }
1333     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1334     {
1335         Status = I_RpcMapWin32Status(RpcExceptionCode());
1336     }
1337     RpcEndExcept;
1338
1339     return Status;
1340 }
1341
1342
1343 NTSTATUS
1344 NTAPI
1345 SamQueryInformationAlias(IN SAM_HANDLE AliasHandle,
1346                          IN ALIAS_INFORMATION_CLASS AliasInformationClass,
1347                          OUT PVOID *Buffer)
1348 {
1349     NTSTATUS Status;
1350
1351     TRACE("SamQueryInformationAlias(%p %lu %p)\n",
1352           AliasHandle, AliasInformationClass, Buffer);
1353
1354     RpcTryExcept
1355     {
1356         Status = SamrQueryInformationAlias((SAMPR_HANDLE)AliasHandle,
1357                                            AliasInformationClass,
1358                                            (PSAMPR_ALIAS_INFO_BUFFER *)Buffer);
1359     }
1360     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1361     {
1362         Status = I_RpcMapWin32Status(RpcExceptionCode());
1363     }
1364     RpcEndExcept;
1365
1366     return Status;
1367 }
1368
1369
1370 NTSTATUS
1371 NTAPI
1372 SamQueryInformationDomain(IN SAM_HANDLE DomainHandle,
1373                           IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
1374                           OUT PVOID *Buffer)
1375 {
1376     NTSTATUS Status;
1377
1378     TRACE("SamQueryInformationDomain(%p %lu %p)\n",
1379           DomainHandle, DomainInformationClass, Buffer);
1380
1381     RpcTryExcept
1382     {
1383         Status = SamrQueryInformationDomain((SAMPR_HANDLE)DomainHandle,
1384                                             DomainInformationClass,
1385                                             (PSAMPR_DOMAIN_INFO_BUFFER *)Buffer);
1386     }
1387     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1388     {
1389         Status = I_RpcMapWin32Status(RpcExceptionCode());
1390     }
1391     RpcEndExcept;
1392
1393     return Status;
1394 }
1395
1396
1397 NTSTATUS
1398 NTAPI
1399 SamQueryInformationGroup(IN SAM_HANDLE GroupHandle,
1400                          IN GROUP_INFORMATION_CLASS GroupInformationClass,
1401                          OUT PVOID *Buffer)
1402 {
1403     NTSTATUS Status;
1404
1405     TRACE("SamQueryInformationGroup(%p %lu %p)\n",
1406           GroupHandle, GroupInformationClass, Buffer);
1407
1408     RpcTryExcept
1409     {
1410         Status = SamrQueryInformationGroup((SAMPR_HANDLE)GroupHandle,
1411                                            GroupInformationClass,
1412                                            (PSAMPR_GROUP_INFO_BUFFER *)Buffer);
1413     }
1414     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1415     {
1416         Status = I_RpcMapWin32Status(RpcExceptionCode());
1417     }
1418     RpcEndExcept;
1419
1420     return Status;
1421 }
1422
1423
1424 NTSTATUS
1425 NTAPI
1426 SamQueryInformationUser(IN SAM_HANDLE UserHandle,
1427                         IN USER_INFORMATION_CLASS UserInformationClass,
1428                         OUT PVOID *Buffer)
1429 {
1430     NTSTATUS Status;
1431
1432     TRACE("SamQueryInformationUser(%p %lu %p)\n",
1433           UserHandle, UserInformationClass, Buffer);
1434
1435     RpcTryExcept
1436     {
1437         Status = SamrQueryInformationUser((SAMPR_HANDLE)UserHandle,
1438                                           UserInformationClass,
1439                                           (PSAMPR_USER_INFO_BUFFER *)Buffer);
1440     }
1441     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1442     {
1443         Status = I_RpcMapWin32Status(RpcExceptionCode());
1444     }
1445     RpcEndExcept;
1446
1447     return Status;
1448 }
1449
1450
1451 NTSTATUS
1452 NTAPI
1453 SamQuerySecurityObject(IN SAM_HANDLE ObjectHandle,
1454                        IN SECURITY_INFORMATION SecurityInformation,
1455                        OUT PSECURITY_DESCRIPTOR *SecurityDescriptor)
1456 {
1457     SAMPR_SR_SECURITY_DESCRIPTOR LocalSecurityDescriptor;
1458     PSAMPR_SR_SECURITY_DESCRIPTOR pLocalSecurityDescriptor;
1459     NTSTATUS Status;
1460
1461     TRACE("SamQuerySecurityObject(%p %lu %p)\n",
1462           ObjectHandle, SecurityInformation, SecurityDescriptor);
1463
1464     LocalSecurityDescriptor.Length = 0;
1465     LocalSecurityDescriptor.SecurityDescriptor = NULL;
1466
1467     RpcTryExcept
1468     {
1469         pLocalSecurityDescriptor = &LocalSecurityDescriptor;
1470
1471         Status = SamrQuerySecurityObject((SAMPR_HANDLE)ObjectHandle,
1472                                          SecurityInformation,
1473                                          &pLocalSecurityDescriptor);
1474     }
1475     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1476     {
1477         Status = I_RpcMapWin32Status(RpcExceptionCode());
1478     }
1479     RpcEndExcept;
1480
1481     *SecurityDescriptor = LocalSecurityDescriptor.SecurityDescriptor;
1482
1483     return Status;
1484 }
1485
1486
1487 NTSTATUS
1488 NTAPI
1489 SamRemoveMemberFromAlias(IN SAM_HANDLE AliasHandle,
1490                          IN PSID MemberId)
1491 {
1492     NTSTATUS Status;
1493
1494     TRACE("SamRemoveMemberFromAlias(%p %ul)\n",
1495           AliasHandle, MemberId);
1496
1497     RpcTryExcept
1498     {
1499         Status = SamrRemoveMemberFromAlias((SAMPR_HANDLE)AliasHandle,
1500                                            MemberId);
1501     }
1502     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1503     {
1504         Status = I_RpcMapWin32Status(RpcExceptionCode());
1505     }
1506     RpcEndExcept;
1507
1508     return Status;
1509 }
1510
1511
1512 NTSTATUS
1513 NTAPI
1514 SamRemoveMemberFromForeignDomain(IN SAM_HANDLE DomainHandle,
1515                                  IN PSID MemberId)
1516 {
1517     NTSTATUS Status;
1518
1519     TRACE("SamRemoveMemberFromForeignDomain(%p %ul)\n",
1520           DomainHandle, MemberId);
1521
1522     RpcTryExcept
1523     {
1524         Status = SamrRemoveMemberFromForeignDomain((SAMPR_HANDLE)DomainHandle,
1525                                                    MemberId);
1526     }
1527     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1528     {
1529         Status = I_RpcMapWin32Status(RpcExceptionCode());
1530     }
1531     RpcEndExcept;
1532
1533     return Status;
1534 }
1535
1536
1537 NTSTATUS
1538 NTAPI
1539 SamRemoveMemberFromGroup(IN SAM_HANDLE GroupHandle,
1540                          IN ULONG MemberId)
1541 {
1542     NTSTATUS Status;
1543
1544     TRACE("SamRemoveMemberFromGroup(%p %ul)\n",
1545           GroupHandle, MemberId);
1546
1547     RpcTryExcept
1548     {
1549         Status = SamrRemoveMemberFromGroup((SAMPR_HANDLE)GroupHandle,
1550                                            MemberId);
1551     }
1552     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1553     {
1554         Status = I_RpcMapWin32Status(RpcExceptionCode());
1555     }
1556     RpcEndExcept;
1557
1558     return Status;
1559 }
1560
1561
1562 NTSTATUS
1563 NTAPI
1564 SamRemoveMultipleMembersFromAlias(IN SAM_HANDLE AliasHandle,
1565                                   IN PSID *MemberIds,
1566                                   IN ULONG MemberCount)
1567 {
1568     SAMPR_PSID_ARRAY Buffer;
1569     NTSTATUS Status;
1570
1571     TRACE("SamRemoveMultipleMembersFromAlias(%p %p %lu)\n",
1572           AliasHandle, MemberIds, MemberCount);
1573
1574     if (MemberIds == NULL)
1575         return STATUS_INVALID_PARAMETER_2;
1576
1577     Buffer.Count = MemberCount;
1578     Buffer.Sids = (PSAMPR_SID_INFORMATION)MemberIds;
1579
1580     RpcTryExcept
1581     {
1582         Status = SamrRemoveMultipleMembersFromAlias((SAMPR_HANDLE)AliasHandle,
1583                                                     &Buffer);
1584     }
1585     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1586     {
1587         Status = I_RpcMapWin32Status(RpcExceptionCode());
1588     }
1589     RpcEndExcept;
1590
1591     return Status;
1592 }
1593
1594
1595 NTSTATUS
1596 NTAPI
1597 SamRidToSid(IN SAM_HANDLE ObjectHandle,
1598             IN ULONG Rid,
1599             OUT PSID *Sid)
1600 {
1601     UNIMPLEMENTED;
1602     return STATUS_NOT_IMPLEMENTED;
1603 }
1604
1605
1606 NTSTATUS
1607 NTAPI
1608 SamSetInformationAlias(IN SAM_HANDLE AliasHandle,
1609                        IN ALIAS_INFORMATION_CLASS AliasInformationClass,
1610                        IN PVOID Buffer)
1611 {
1612     NTSTATUS Status;
1613
1614     TRACE("SamSetInformationAlias(%p %lu %p)\n",
1615           AliasHandle, AliasInformationClass, Buffer);
1616
1617     RpcTryExcept
1618     {
1619         Status = SamrSetInformationAlias((SAMPR_HANDLE)AliasHandle,
1620                                          AliasInformationClass,
1621                                          Buffer);
1622     }
1623     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1624     {
1625         Status = I_RpcMapWin32Status(RpcExceptionCode());
1626     }
1627     RpcEndExcept;
1628
1629     return Status;
1630 }
1631
1632
1633 NTSTATUS
1634 NTAPI
1635 SamSetInformationDomain(IN SAM_HANDLE DomainHandle,
1636                         IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
1637                         IN PVOID Buffer)
1638 {
1639     NTSTATUS Status;
1640
1641     TRACE("SamSetInformationDomain(%p %lu %p)\n",
1642           DomainHandle, DomainInformationClass, Buffer);
1643
1644     RpcTryExcept
1645     {
1646         Status = SamrSetInformationDomain((SAMPR_HANDLE)DomainHandle,
1647                                           DomainInformationClass,
1648                                           Buffer);
1649     }
1650     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1651     {
1652         Status = I_RpcMapWin32Status(RpcExceptionCode());
1653     }
1654     RpcEndExcept;
1655
1656     return Status;
1657 }
1658
1659
1660 NTSTATUS
1661 NTAPI
1662 SamSetInformationGroup(IN SAM_HANDLE GroupHandle,
1663                        IN GROUP_INFORMATION_CLASS GroupInformationClass,
1664                        IN PVOID Buffer)
1665 {
1666     NTSTATUS Status;
1667
1668     TRACE("SamSetInformationGroup(%p %lu %p)\n",
1669           GroupHandle, GroupInformationClass, Buffer);
1670
1671     RpcTryExcept
1672     {
1673         Status = SamrSetInformationGroup((SAMPR_HANDLE)GroupHandle,
1674                                          GroupInformationClass,
1675                                          Buffer);
1676     }
1677     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1678     {
1679         Status = I_RpcMapWin32Status(RpcExceptionCode());
1680     }
1681     RpcEndExcept;
1682
1683     return Status;
1684 }
1685
1686
1687 NTSTATUS
1688 NTAPI
1689 SamSetInformationUser(IN SAM_HANDLE UserHandle,
1690                       IN USER_INFORMATION_CLASS UserInformationClass,
1691                       IN PVOID Buffer)
1692 {
1693     PSAMPR_USER_SET_PASSWORD_INFORMATION PasswordBuffer;
1694     SAMPR_USER_INTERNAL1_INFORMATION Internal1Buffer;
1695     OEM_STRING LmPwdString;
1696     CHAR LmPwdBuffer[15];
1697     NTSTATUS Status;
1698
1699     TRACE("SamSetInformationUser(%p %lu %p)\n",
1700           UserHandle, UserInformationClass, Buffer);
1701
1702     if (UserInformationClass == UserSetPasswordInformation)
1703     {
1704         PasswordBuffer = (PSAMPR_USER_SET_PASSWORD_INFORMATION)Buffer;
1705
1706         /* Calculate the NT hash value of the passord */
1707         Status = SystemFunction007((PUNICODE_STRING)&PasswordBuffer->Password,
1708                                    (LPBYTE)&Internal1Buffer.EncryptedNtOwfPassword);
1709         if (!NT_SUCCESS(Status))
1710         {
1711             TRACE("SystemFunction007 failed (Status 0x%08lx)\n", Status);
1712             return Status;
1713         }
1714
1715         Internal1Buffer.NtPasswordPresent = TRUE;
1716         Internal1Buffer.LmPasswordPresent = FALSE;
1717
1718         /* Build the LM password */
1719         LmPwdString.Length = 15;
1720         LmPwdString.MaximumLength = 15;
1721         LmPwdString.Buffer = LmPwdBuffer;
1722         ZeroMemory(LmPwdString.Buffer, LmPwdString.MaximumLength);
1723
1724         Status = RtlUpcaseUnicodeStringToOemString(&LmPwdString,
1725                                                    (PUNICODE_STRING)&PasswordBuffer->Password,
1726                                                    FALSE);
1727         if (NT_SUCCESS(Status))
1728         {
1729             /* Calculate the LM hash value of the password */
1730             Status = SystemFunction006(LmPwdString.Buffer,
1731                                        (LPSTR)&Internal1Buffer.EncryptedLmOwfPassword);
1732             if (NT_SUCCESS(Status))
1733                 Internal1Buffer.LmPasswordPresent = TRUE;
1734         }
1735
1736         Internal1Buffer.PasswordExpired = PasswordBuffer->PasswordExpired;
1737
1738         RpcTryExcept
1739         {
1740             Status = SamrSetInformationUser((SAMPR_HANDLE)UserHandle,
1741                                             UserInternal1Information,
1742                                             (PVOID)&Internal1Buffer);
1743         }
1744         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1745         {
1746             Status = I_RpcMapWin32Status(RpcExceptionCode());
1747         }
1748         RpcEndExcept;
1749
1750         if (!NT_SUCCESS(Status))
1751         {
1752             TRACE("SamrSetInformation() failed (Status 0x%08lx)\n", Status);
1753             return Status;
1754         }
1755     }
1756
1757     RpcTryExcept
1758     {
1759         Status = SamrSetInformationUser((SAMPR_HANDLE)UserHandle,
1760                                         UserInformationClass,
1761                                         Buffer);
1762     }
1763     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1764     {
1765         Status = I_RpcMapWin32Status(RpcExceptionCode());
1766     }
1767     RpcEndExcept;
1768
1769     return Status;
1770 }
1771
1772
1773 NTSTATUS
1774 NTAPI
1775 SamSetMemberAttributesOfGroup(IN SAM_HANDLE GroupHandle,
1776                               IN ULONG MemberId,
1777                               IN ULONG Attributes)
1778 {
1779     NTSTATUS Status;
1780
1781     TRACE("SamSetMemberAttributesOfGroup(%p %lu 0x%lx)\n",
1782           GroupHandle, MemberId, Attributes);
1783
1784     RpcTryExcept
1785     {
1786         Status = SamrSetMemberAttributesOfGroup((SAMPR_HANDLE)GroupHandle,
1787                                                 MemberId,
1788                                                 Attributes);
1789     }
1790     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1791     {
1792         Status = I_RpcMapWin32Status(RpcExceptionCode());
1793     }
1794     RpcEndExcept;
1795
1796     return Status;
1797 }
1798
1799
1800 NTSTATUS
1801 NTAPI
1802 SamSetSecurityObject(IN SAM_HANDLE ObjectHandle,
1803                      IN SECURITY_INFORMATION SecurityInformation,
1804                      IN PSECURITY_DESCRIPTOR SecurityDescriptor)
1805 {
1806     SAMPR_SR_SECURITY_DESCRIPTOR DescriptorToPass;
1807     ULONG Length;
1808     NTSTATUS Status;
1809
1810     TRACE("SamSetSecurityObject(%p %lu %p)\n",
1811           ObjectHandle, SecurityInformation, SecurityDescriptor);
1812
1813     /* Retrieve the length of the relative security descriptor */
1814     Length = 0;
1815     Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
1816                                    NULL,
1817                                    &Length);
1818     if (Status != STATUS_BUFFER_TOO_SMALL)
1819         return STATUS_INVALID_PARAMETER;
1820
1821
1822     /* Allocate a buffer for the security descriptor */
1823     DescriptorToPass.Length = Length;
1824     DescriptorToPass.SecurityDescriptor = MIDL_user_allocate(Length);
1825     if (DescriptorToPass.SecurityDescriptor == NULL)
1826         return STATUS_INSUFFICIENT_RESOURCES;
1827
1828     /* Convert the given security descriptor to a relative security descriptor */
1829     Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
1830                                    (PSECURITY_DESCRIPTOR)DescriptorToPass.SecurityDescriptor,
1831                                    &Length);
1832     if (!NT_SUCCESS(Status))
1833         goto done;
1834
1835     RpcTryExcept
1836     {
1837         Status = SamrSetSecurityObject((SAMPR_HANDLE)ObjectHandle,
1838                                        SecurityInformation,
1839                                        &DescriptorToPass);
1840     }
1841     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1842     {
1843         Status = I_RpcMapWin32Status(RpcExceptionCode());
1844     }
1845     RpcEndExcept;
1846
1847 done:
1848     if (DescriptorToPass.SecurityDescriptor != NULL)
1849         MIDL_user_free(DescriptorToPass.SecurityDescriptor);
1850
1851     return Status;
1852 }
1853
1854
1855 NTSTATUS
1856 NTAPI
1857 SamShutdownSamServer(IN SAM_HANDLE ServerHandle)
1858 {
1859     NTSTATUS Status;
1860
1861     TRACE("(%p)\n", ServerHandle);
1862
1863     RpcTryExcept
1864     {
1865         Status = SamrShutdownSamServer((SAMPR_HANDLE)ServerHandle);
1866     }
1867     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1868     {
1869         Status = I_RpcMapWin32Status(RpcExceptionCode());
1870     }
1871     RpcEndExcept;
1872
1873     return Status;
1874 }
1875
1876 /* EOF */