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