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