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 SamGetGroupsForUser(IN SAM_HANDLE UserHandle,
 727                     OUT PGROUP_MEMBERSHIP *Groups,
 728                     OUT PULONG MembershipCount)
 729 {
 730     PSAMPR_GET_GROUPS_BUFFER GroupsBuffer = NULL;
 731     NTSTATUS Status;
 732
 733     TRACE("SamGetGroupsForUser(%p %p %p)\n",
 734           UserHandle, Groups, MembershipCount);
 735
 736     RpcTryExcept
 737     {
 738         Status = SamrGetGroupsForUser((SAMPR_HANDLE)UserHandle,
 739                                       &GroupsBuffer);
 740         if (NT_SUCCESS(Status))
 741         {
 742             *Groups = GroupsBuffer->Groups;
 743             *MembershipCount = GroupsBuffer->MembershipCount;
 744
 745             MIDL_user_free(GroupsBuffer);
 746         }
 747         else
 748         {
 749             if (GroupsBuffer != NULL)
 750             {
 751                 if (GroupsBuffer->Groups != NULL)
 752                     MIDL_user_free(GroupsBuffer->Groups);
 753
 754                 MIDL_user_free(GroupsBuffer);
 755             }
 756         }
 757     }
 758     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 759     {
 760         Status = I_RpcMapWin32Status(RpcExceptionCode());
 761     }
 762     RpcEndExcept;
 763
 764     return Status;
 765 }
 766
 767
 768 NTSTATUS
 769 NTAPI
 770 SamGetMembersInAlias(IN SAM_HANDLE AliasHandle,
 771                      OUT PSID **MemberIds,
 772                      OUT PULONG MemberCount)
 773 {
 774     SAMPR_PSID_ARRAY_OUT SidArray;
 775     NTSTATUS Status;
 776
 777     TRACE("SamGetMembersInAlias(%p %p %p)\n",
 778           AliasHandle, MemberIds, MemberCount);
 779
 780     if ((MemberIds == NULL) ||
 781         (MemberCount == NULL))
 782         return STATUS_INVALID_PARAMETER;
 783
 784     *MemberIds = NULL;
 785     *MemberCount = 0;
 786
 787     SidArray.Sids = NULL;
 788
 789     RpcTryExcept
 790     {
 791         Status = SamrGetMembersInAlias((SAMPR_HANDLE)AliasHandle,
 792                                        &SidArray);
 793         if (NT_SUCCESS(Status))
 794         {
 795             *MemberCount = SidArray.Count;
 796             *MemberIds = (PSID *)SidArray.Sids;
 797         }
 798
 799     }
 800     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 801     {
 802         Status = I_RpcMapWin32Status(RpcExceptionCode());
 803     }
 804     RpcEndExcept;
 805
 806     return Status;
 807 }
 808
 809
 810 NTSTATUS
 811 NTAPI
 812 SamGetMembersInGroup(IN SAM_HANDLE GroupHandle,
 813                      OUT PULONG *MemberIds,
 814                      OUT PULONG *Attributes,
 815                      OUT PULONG MemberCount)
 816 {
 817     PSAMPR_GET_MEMBERS_BUFFER MembersBuffer = NULL;
 818     NTSTATUS Status;
 819
 820     TRACE("SamGetMembersInGroup(%p %p %p %p)\n",
 821           GroupHandle, MemberIds, Attributes, MemberCount);
 822
 823     RpcTryExcept
 824     {
 825         Status = SamrGetMembersInGroup((SAMPR_HANDLE)GroupHandle,
 826                                        &MembersBuffer);
 827         if (NT_SUCCESS(Status))
 828         {
 829             *MemberIds = MembersBuffer->Members;
 830             *Attributes = MembersBuffer->Attributes;
 831             *MemberCount = MembersBuffer->MemberCount;
 832
 833             MIDL_user_free(MembersBuffer);
 834         }
 835         else
 836         {
 837             if (MembersBuffer != NULL)
 838             {
 839                 if (MembersBuffer->Members != NULL)
 840                     MIDL_user_free(MembersBuffer->Members);
 841
 842                 if (MembersBuffer->Attributes != NULL)
 843                     MIDL_user_free(MembersBuffer->Attributes);
 844
 845                 MIDL_user_free(MembersBuffer);
 846             }
 847         }
 848     }
 849     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 850     {
 851         Status = I_RpcMapWin32Status(RpcExceptionCode());
 852     }
 853     RpcEndExcept;
 854
 855     return Status;
 856 }
 857
 858
 859 NTSTATUS
 860 NTAPI
 861 SamLookupDomainInSamServer(IN SAM_HANDLE ServerHandle,
 862                            IN PUNICODE_STRING Name,
 863                            OUT PSID *DomainId)
 864 {
 865     NTSTATUS Status;
 866
 867     TRACE("SamLookupDomainInSamServer(%p %p %p)\n",
 868           ServerHandle, Name, DomainId);
 869
 870     RpcTryExcept
 871     {
 872         Status = SamrLookupDomainInSamServer((SAMPR_HANDLE)ServerHandle,
 873                                              (PRPC_UNICODE_STRING)Name,
 874                                              (PRPC_SID *)DomainId);
 875     }
 876     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 877     {
 878         Status = I_RpcMapWin32Status(RpcExceptionCode());
 879     }
 880     RpcEndExcept;
 881
 882     return Status;
 883 }
 884
 885
 886 NTSTATUS
 887 NTAPI
 888 SamLookupIdsInDomain(IN SAM_HANDLE DomainHandle,
 889                      IN ULONG Count,
 890                      IN PULONG RelativeIds,
 891                      OUT PUNICODE_STRING *Names,
 892                      OUT PSID_NAME_USE *Use)
 893 {
 894     SAMPR_RETURNED_USTRING_ARRAY NamesBuffer = {0, NULL};
 895     SAMPR_ULONG_ARRAY UseBuffer = {0, NULL};
 896     ULONG i;
 897     NTSTATUS Status;
 898
 899     TRACE("SamLookupIdsInDomain(%p %lu %p %p %p)\n",
 900           DomainHandle, Count, RelativeIds, Names, Use);
 901
 902     *Names = NULL;
 903     *Use = NULL;
 904
 905     RpcTryExcept
 906     {
 907         Status = SamrLookupIdsInDomain((SAMPR_HANDLE)DomainHandle,
 908                                        Count,
 909                                        RelativeIds,
 910                                        &NamesBuffer,
 911                                        &UseBuffer);
 912     }
 913     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 914     {
 915         Status = I_RpcMapWin32Status(RpcExceptionCode());
 916     }
 917     RpcEndExcept;
 918
 919     if (NT_SUCCESS(Status))
 920     {
 921         *Names = midl_user_allocate(Count * sizeof(RPC_UNICODE_STRING));
 922         if (*Names == NULL)
 923         {
 924             Status = STATUS_INSUFFICIENT_RESOURCES;
 925             goto done;
 926         }
 927
 928         for (i = 0; i < Count; i++)
 929         {
 930             (*Names)[i].Buffer = midl_user_allocate(NamesBuffer.Element[i].MaximumLength);
 931             if ((*Names)[i].Buffer == NULL)
 932             {
 933                 Status = STATUS_INSUFFICIENT_RESOURCES;
 934                 goto done;
 935             }
 936         }
 937
 938         *Use = midl_user_allocate(Count * sizeof(SID_NAME_USE));
 939         if (*Use == NULL)
 940         {
 941             Status = STATUS_INSUFFICIENT_RESOURCES;
 942             goto done;
 943         }
 944
 945         for (i = 0; i < Count; i++)
 946         {
 947             (*Names)[i].Length = NamesBuffer.Element[i].Length;
 948             (*Names)[i].MaximumLength = NamesBuffer.Element[i].MaximumLength;
 949
 950             RtlCopyMemory((*Names)[i].Buffer,
 951                           NamesBuffer.Element[i].Buffer,
 952                           NamesBuffer.Element[i].Length);
 953         }
 954
 955         RtlCopyMemory(*Use,
 956                       UseBuffer.Element,
 957                       Count * sizeof(SID_NAME_USE));
 958     }
 959
 960 done:
 961     if (!NT_SUCCESS(Status))
 962     {
 963         if (*Names != NULL)
 964         {
 965             for (i = 0; i < Count; i++)
 966             {
 967                 if ((*Names)[i].Buffer != NULL)
 968                     midl_user_free((*Names)[i].Buffer);
 969             }
 970
 971             midl_user_free(*Names);
 972         }
 973
 974         if (*Use != NULL)
 975             midl_user_free(*Use);
 976     }
 977
 978     if (NamesBuffer.Element != NULL)
 979     {
 980         for (i = 0; i < NamesBuffer.Count; i++)
 981         {
 982             if (NamesBuffer.Element[i].Buffer != NULL)
 983                 midl_user_free(NamesBuffer.Element[i].Buffer);
 984         }
 985
 986         midl_user_free(NamesBuffer.Element);
 987     }
 988
 989     if (UseBuffer.Element != NULL)
 990         midl_user_free(UseBuffer.Element);
 991
 992     return 0;
 993 }
 994
 995
 996 NTSTATUS
 997 NTAPI
 998 SamLookupNamesInDomain(IN SAM_HANDLE DomainHandle,
 999                        IN ULONG Count,
1000                        IN PUNICODE_STRING Names,
1001                        OUT PULONG *RelativeIds,
1002                        OUT PSID_NAME_USE *Use)
1003 {
1004     SAMPR_ULONG_ARRAY RidBuffer = {0, NULL};
1005     SAMPR_ULONG_ARRAY UseBuffer = {0, NULL};
1006     NTSTATUS Status;
1007
1008     TRACE("SamLookupNamesInDomain(%p %lu %p %p %p)\n",
1009           DomainHandle, Count, Names, RelativeIds, Use);
1010
1011     *RelativeIds = NULL;
1012     *Use = NULL;
1013
1014     RpcTryExcept
1015     {
1016         Status = SamrLookupNamesInDomain((SAMPR_HANDLE)DomainHandle,
1017                                          Count,
1018                                          (PRPC_UNICODE_STRING)Names,
1019                                          &RidBuffer,
1020                                          &UseBuffer);
1021     }
1022     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1023     {
1024         Status = I_RpcMapWin32Status(RpcExceptionCode());
1025     }
1026     RpcEndExcept;
1027
1028     if (NT_SUCCESS(Status))
1029     {
1030         *RelativeIds = midl_user_allocate(Count * sizeof(ULONG));
1031         if (*RelativeIds == NULL)
1032         {
1033             Status = STATUS_INSUFFICIENT_RESOURCES;
1034             goto done;
1035         }
1036
1037         *Use = midl_user_allocate(Count * sizeof(SID_NAME_USE));
1038         if (*Use == NULL)
1039         {
1040             Status = STATUS_INSUFFICIENT_RESOURCES;
1041             goto done;
1042         }
1043
1044         RtlCopyMemory(*RelativeIds,
1045                       RidBuffer.Element,
1046                       Count * sizeof(ULONG));
1047
1048         RtlCopyMemory(*Use,
1049                       UseBuffer.Element,
1050                       Count * sizeof(SID_NAME_USE));
1051     }
1052
1053 done:
1054     if (!NT_SUCCESS(Status))
1055     {
1056         if (*RelativeIds != NULL)
1057             midl_user_free(*RelativeIds);
1058
1059         if (*Use != NULL)
1060             midl_user_free(*Use);
1061     }
1062
1063     if (RidBuffer.Element != NULL)
1064         midl_user_free(RidBuffer.Element);
1065
1066     if (UseBuffer.Element != NULL)
1067         midl_user_free(UseBuffer.Element);
1068
1069     return Status;
1070 }
1071
1072
1073 NTSTATUS
1074 NTAPI
1075 SamOpenAlias(IN SAM_HANDLE DomainHandle,
1076              IN ACCESS_MASK DesiredAccess,
1077              IN ULONG AliasId,
1078              OUT PSAM_HANDLE AliasHandle)
1079 {
1080     NTSTATUS Status;
1081
1082     TRACE("SamOpenAlias(%p 0x%08x %lx %p)\n",
1083           DomainHandle, DesiredAccess, AliasId, AliasHandle);
1084
1085     RpcTryExcept
1086     {
1087         Status = SamrOpenAlias((SAMPR_HANDLE)DomainHandle,
1088                                DesiredAccess,
1089                                AliasId,
1090                                (SAMPR_HANDLE *)AliasHandle);
1091     }
1092     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1093     {
1094         Status = I_RpcMapWin32Status(RpcExceptionCode());
1095     }
1096     RpcEndExcept;
1097
1098     return Status;
1099 }
1100
1101
1102 NTSTATUS
1103 NTAPI
1104 SamOpenDomain(IN SAM_HANDLE ServerHandle,
1105               IN ACCESS_MASK DesiredAccess,
1106               IN PSID DomainId,
1107               OUT PSAM_HANDLE DomainHandle)
1108 {
1109     NTSTATUS Status;
1110
1111     TRACE("SamOpenDomain(%p 0x%08x %p %p)\n",
1112           ServerHandle, DesiredAccess, DomainId, DomainHandle);
1113
1114     RpcTryExcept
1115     {
1116         Status = SamrOpenDomain((SAMPR_HANDLE)ServerHandle,
1117                                 DesiredAccess,
1118                                 (PRPC_SID)DomainId,
1119                                 (SAMPR_HANDLE *)DomainHandle);
1120     }
1121     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1122     {
1123         Status = I_RpcMapWin32Status(RpcExceptionCode());
1124     }
1125     RpcEndExcept;
1126
1127     return Status;
1128 }
1129
1130
1131 NTSTATUS
1132 NTAPI
1133 SamOpenGroup(IN SAM_HANDLE DomainHandle,
1134              IN ACCESS_MASK DesiredAccess,
1135              IN ULONG GroupId,
1136              OUT PSAM_HANDLE GroupHandle)
1137 {
1138     NTSTATUS Status;
1139
1140     TRACE("SamOpenGroup(%p 0x%08x %p %p)\n",
1141           DomainHandle, DesiredAccess, GroupId, GroupHandle);
1142
1143     RpcTryExcept
1144     {
1145         Status = SamrOpenGroup((SAMPR_HANDLE)DomainHandle,
1146                                DesiredAccess,
1147                                GroupId,
1148                                (SAMPR_HANDLE *)GroupHandle);
1149     }
1150     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1151     {
1152         Status = I_RpcMapWin32Status(RpcExceptionCode());
1153     }
1154     RpcEndExcept;
1155
1156     return Status;
1157 }
1158
1159
1160 NTSTATUS
1161 NTAPI
1162 SamOpenUser(IN SAM_HANDLE DomainHandle,
1163             IN ACCESS_MASK DesiredAccess,
1164             IN ULONG UserId,
1165             OUT PSAM_HANDLE UserHandle)
1166 {
1167     NTSTATUS Status;
1168
1169     TRACE("SamOpenUser(%p 0x%08x %lx %p)\n",
1170           DomainHandle, DesiredAccess, UserId, UserHandle);
1171
1172     RpcTryExcept
1173     {
1174         Status = SamrOpenUser((SAMPR_HANDLE)DomainHandle,
1175                               DesiredAccess,
1176                               UserId,
1177                               (SAMPR_HANDLE *)UserHandle);
1178     }
1179     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1180     {
1181         Status = I_RpcMapWin32Status(RpcExceptionCode());
1182     }
1183     RpcEndExcept;
1184
1185     return Status;
1186 }
1187
1188
1189 NTSTATUS
1190 NTAPI
1191 SamQueryInformationAlias(IN SAM_HANDLE AliasHandle,
1192                          IN ALIAS_INFORMATION_CLASS AliasInformationClass,
1193                          OUT PVOID *Buffer)
1194 {
1195     NTSTATUS Status;
1196
1197     TRACE("SamQueryInformationAlias(%p %lu %p)\n",
1198           AliasHandle, AliasInformationClass, Buffer);
1199
1200     RpcTryExcept
1201     {
1202         Status = SamrQueryInformationAlias((SAMPR_HANDLE)AliasHandle,
1203                                            AliasInformationClass,
1204                                            (PSAMPR_ALIAS_INFO_BUFFER *)Buffer);
1205     }
1206     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1207     {
1208         Status = I_RpcMapWin32Status(RpcExceptionCode());
1209     }
1210     RpcEndExcept;
1211
1212     return Status;
1213 }
1214
1215
1216 NTSTATUS
1217 NTAPI
1218 SamQueryInformationDomain(IN SAM_HANDLE DomainHandle,
1219                           IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
1220                           OUT PVOID *Buffer)
1221 {
1222     NTSTATUS Status;
1223
1224     TRACE("SamQueryInformationDomain(%p %lu %p)\n",
1225           DomainHandle, DomainInformationClass, Buffer);
1226
1227     RpcTryExcept
1228     {
1229         Status = SamrQueryInformationDomain((SAMPR_HANDLE)DomainHandle,
1230                                             DomainInformationClass,
1231                                             (PSAMPR_DOMAIN_INFO_BUFFER *)Buffer);
1232     }
1233     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1234     {
1235         Status = I_RpcMapWin32Status(RpcExceptionCode());
1236     }
1237     RpcEndExcept;
1238
1239     return Status;
1240 }
1241
1242
1243 NTSTATUS
1244 NTAPI
1245 SamQueryInformationGroup(IN SAM_HANDLE GroupHandle,
1246                          IN GROUP_INFORMATION_CLASS GroupInformationClass,
1247                          OUT PVOID *Buffer)
1248 {
1249     NTSTATUS Status;
1250
1251     TRACE("SamQueryInformationGroup(%p %lu %p)\n",
1252           GroupHandle, GroupInformationClass, Buffer);
1253
1254     RpcTryExcept
1255     {
1256         Status = SamrQueryInformationGroup((SAMPR_HANDLE)GroupHandle,
1257                                            GroupInformationClass,
1258                                            (PSAMPR_GROUP_INFO_BUFFER *)Buffer);
1259     }
1260     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1261     {
1262         Status = I_RpcMapWin32Status(RpcExceptionCode());
1263     }
1264     RpcEndExcept;
1265
1266     return Status;
1267 }
1268
1269
1270 NTSTATUS
1271 NTAPI
1272 SamQueryInformationUser(IN SAM_HANDLE UserHandle,
1273                         IN USER_INFORMATION_CLASS UserInformationClass,
1274                         OUT PVOID *Buffer)
1275 {
1276     NTSTATUS Status;
1277
1278     TRACE("SamQueryInformationUser(%p %lu %p)\n",
1279           UserHandle, UserInformationClass, Buffer);
1280
1281     RpcTryExcept
1282     {
1283         Status = SamrQueryInformationUser((SAMPR_HANDLE)UserHandle,
1284                                           UserInformationClass,
1285                                           (PSAMPR_USER_INFO_BUFFER *)Buffer);
1286     }
1287     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1288     {
1289         Status = I_RpcMapWin32Status(RpcExceptionCode());
1290     }
1291     RpcEndExcept;
1292
1293     return Status;
1294 }
1295
1296
1297 NTSTATUS
1298 NTAPI
1299 SamQuerySecurityObject(IN SAM_HANDLE ObjectHandle,
1300                        IN SECURITY_INFORMATION SecurityInformation,
1301                        OUT PSECURITY_DESCRIPTOR *SecurityDescriptor)
1302 {
1303     SAMPR_SR_SECURITY_DESCRIPTOR LocalSecurityDescriptor;
1304     PSAMPR_SR_SECURITY_DESCRIPTOR pLocalSecurityDescriptor;
1305     NTSTATUS Status;
1306
1307     TRACE("SamQuerySecurityObject(%p %lu %p)\n",
1308           ObjectHandle, SecurityInformation, SecurityDescriptor);
1309
1310     LocalSecurityDescriptor.Length = 0;
1311     LocalSecurityDescriptor.SecurityDescriptor = NULL;
1312
1313     RpcTryExcept
1314     {
1315         pLocalSecurityDescriptor = &LocalSecurityDescriptor;
1316
1317         Status = SamrQuerySecurityObject((SAMPR_HANDLE)ObjectHandle,
1318                                          SecurityInformation,
1319                                          &pLocalSecurityDescriptor);
1320     }
1321     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1322     {
1323         Status = I_RpcMapWin32Status(RpcExceptionCode());
1324     }
1325     RpcEndExcept;
1326
1327     *SecurityDescriptor = LocalSecurityDescriptor.SecurityDescriptor;
1328
1329     return Status;
1330 }
1331
1332
1333 NTSTATUS
1334 NTAPI
1335 SamRidToSid(IN SAM_HANDLE ObjectHandle,
1336             IN ULONG Rid,
1337             OUT PSID *Sid)
1338 {
1339     UNIMPLEMENTED;
1340     return STATUS_NOT_IMPLEMENTED;
1341 }
1342
1343
1344 NTSTATUS
1345 NTAPI
1346 SamSetInformationAlias(IN SAM_HANDLE AliasHandle,
1347                        IN ALIAS_INFORMATION_CLASS AliasInformationClass,
1348                        IN PVOID Buffer)
1349 {
1350     NTSTATUS Status;
1351
1352     TRACE("SamSetInformationAlias(%p %lu %p)\n",
1353           AliasHandle, AliasInformationClass, Buffer);
1354
1355     RpcTryExcept
1356     {
1357         Status = SamrSetInformationAlias((SAMPR_HANDLE)AliasHandle,
1358                                          AliasInformationClass,
1359                                          Buffer);
1360     }
1361     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1362     {
1363         Status = I_RpcMapWin32Status(RpcExceptionCode());
1364     }
1365     RpcEndExcept;
1366
1367     return Status;
1368 }
1369
1370
1371 NTSTATUS
1372 NTAPI
1373 SamSetInformationDomain(IN SAM_HANDLE DomainHandle,
1374                         IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
1375                         IN PVOID Buffer)
1376 {
1377     NTSTATUS Status;
1378
1379     TRACE("SamSetInformationDomain(%p %lu %p)\n",
1380           DomainHandle, DomainInformationClass, Buffer);
1381
1382     RpcTryExcept
1383     {
1384         Status = SamrSetInformationDomain((SAMPR_HANDLE)DomainHandle,
1385                                           DomainInformationClass,
1386                                           Buffer);
1387     }
1388     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1389     {
1390         Status = I_RpcMapWin32Status(RpcExceptionCode());
1391     }
1392     RpcEndExcept;
1393
1394     return Status;
1395 }
1396
1397
1398 NTSTATUS
1399 NTAPI
1400 SamSetInformationGroup(IN SAM_HANDLE GroupHandle,
1401                        IN GROUP_INFORMATION_CLASS GroupInformationClass,
1402                        IN PVOID Buffer)
1403 {
1404     NTSTATUS Status;
1405
1406     TRACE("SamSetInformationGroup(%p %lu %p)\n",
1407           GroupHandle, GroupInformationClass, Buffer);
1408
1409     RpcTryExcept
1410     {
1411         Status = SamrSetInformationGroup((SAMPR_HANDLE)GroupHandle,
1412                                          GroupInformationClass,
1413                                          Buffer);
1414     }
1415     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1416     {
1417         Status = I_RpcMapWin32Status(RpcExceptionCode());
1418     }
1419     RpcEndExcept;
1420
1421     return Status;
1422 }
1423
1424
1425 NTSTATUS
1426 NTAPI
1427 SamSetInformationUser(IN SAM_HANDLE UserHandle,
1428                       IN USER_INFORMATION_CLASS UserInformationClass,
1429                       IN PVOID Buffer)
1430 {
1431     NTSTATUS Status;
1432
1433     TRACE("SamSetInformationUser(%p %lu %p)\n",
1434           UserHandle, UserInformationClass, Buffer);
1435
1436     RpcTryExcept
1437     {
1438         Status = SamrSetInformationUser((SAMPR_HANDLE)UserHandle,
1439                                         UserInformationClass,
1440                                         Buffer);
1441     }
1442     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1443     {
1444         Status = I_RpcMapWin32Status(RpcExceptionCode());
1445     }
1446     RpcEndExcept;
1447
1448     return Status;
1449 }
1450
1451
1452 NTSTATUS
1453 NTAPI
1454 SamSetMemberAttributesOfGroup(IN SAM_HANDLE GroupHandle,
1455                               IN ULONG MemberId,
1456                               IN ULONG Attributes)
1457 {
1458     NTSTATUS Status;
1459
1460     TRACE("SamSetMemberAttributesOfGroup(%p %lu 0x%lx)\n",
1461           GroupHandle, MemberId, Attributes);
1462
1463     RpcTryExcept
1464     {
1465         Status = SamrSetMemberAttributesOfGroup((SAMPR_HANDLE)GroupHandle,
1466                                                 MemberId,
1467                                                 Attributes);
1468     }
1469     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1470     {
1471         Status = I_RpcMapWin32Status(RpcExceptionCode());
1472     }
1473     RpcEndExcept;
1474
1475     return Status;
1476 }
1477
1478
1479 NTSTATUS
1480 NTAPI
1481 SamSetSecurityObject(IN SAM_HANDLE ObjectHandle,
1482                      IN SECURITY_INFORMATION SecurityInformation,
1483                      IN PSECURITY_DESCRIPTOR SecurityDescriptor)
1484 {
1485     SAMPR_SR_SECURITY_DESCRIPTOR DescriptorToPass;
1486     ULONG Length;
1487     NTSTATUS Status;
1488
1489     TRACE("SamSetSecurityObject(%p %lu %p)\n",
1490           ObjectHandle, SecurityInformation, SecurityDescriptor);
1491
1492     /* Retrieve the length of the relative security descriptor */
1493     Length = 0;
1494     Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
1495                                    NULL,
1496                                    &Length);
1497     if (Status != STATUS_BUFFER_TOO_SMALL)
1498         return STATUS_INVALID_PARAMETER;
1499
1500
1501     /* Allocate a buffer for the security descriptor */
1502     DescriptorToPass.Length = Length;
1503     DescriptorToPass.SecurityDescriptor = MIDL_user_allocate(Length);
1504     if (DescriptorToPass.SecurityDescriptor == NULL)
1505         return STATUS_INSUFFICIENT_RESOURCES;
1506
1507     /* Convert the given security descriptor to a relative security descriptor */
1508     Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
1509                                    (PSECURITY_DESCRIPTOR)DescriptorToPass.SecurityDescriptor,
1510                                    &Length);
1511     if (!NT_SUCCESS(Status))
1512         goto done;
1513
1514     RpcTryExcept
1515     {
1516         Status = SamrSetSecurityObject((SAMPR_HANDLE)ObjectHandle,
1517                                        SecurityInformation,
1518                                        &DescriptorToPass);
1519     }
1520     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1521     {
1522         Status = I_RpcMapWin32Status(RpcExceptionCode());
1523     }
1524     RpcEndExcept;
1525
1526 done:
1527     if (DescriptorToPass.SecurityDescriptor != NULL)
1528         MIDL_user_free(DescriptorToPass.SecurityDescriptor);
1529
1530     return Status;
1531 }
1532
1533
1534 NTSTATUS
1535 NTAPI
1536 SamShutdownSamServer(IN SAM_HANDLE ServerHandle)
1537 {
1538     UNIMPLEMENTED;
1539     return STATUS_NOT_IMPLEMENTED;
1540 }
1541
1542 /* EOF */